光照模型（Lighting）

最新推荐文章于 2025-02-04 23:46:22 发布
原创 最新推荐文章于 2025-02-04 23:46:22 发布 · 364 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#unity

PBR

D

//-----------------------------------------------------------------------------
// D Iterm
//-----------------------------------------------------------------------------
//**** In UE4, Roughness = Roughness * Roughness;

// [Blinn 1977, "Models of light reflection for computer synthesized pictures"]
float D_Blinn( float Roughness, float NoH )
{
	float a = Roughness * Roughness;
	float a2 = a * a;
	float n = 2 / a2 - 2;
	return (n+2) / (2*PI) * pow( NoH, n );		// 1 mad, 1 exp, 1 mul, 1 log
}

// BlinnPhong normalized as reflection density function (RDF)
// ready for use directly as specular: spec=D
// http://www.thetenthplanet.de/archives/255
inline half D_RDFBlinnPhong( float Roughness, float NoH )
{
	half n = Roughness; //??? with same above?
	return (n+2) / (8*PI) * pow (NoH, n);
}

// [Beckmann 1963, "The scattering of electromagnetic waves from rough surfaces"]
float D_Beckmann( float Roughness, float NoH )
{
	float a = Roughness * Roughness;
	float a2 = a * a;
	float NoH2 = NoH * NoH;
	return exp( (NoH2 - 1) / (a2 * NoH2) ) / ( PI * a2 * NoH2 * NoH2 );
}

half D_PHBeckmann( half Roughness, half NoH ) 
{
	float a = Roughness * Roughness;
	float a2 = a * a;
	half alpha = cos( NoH );
	half ta = tan( alpha );
	return 1 /( a2 * pow( NoH, 4 ) ) * exp(-( ta * ta ) / ( a2 ));
}

// GGX / Trowbridge-Reitz
// [Walter et al. 2007, "Microfacet models for refraction through rough surfaces"]
half D_GGX( half Roughness, half NoH )
{
	half a = Roughness * Roughness;
	half a2 = a * a;
	half d = ( NoH * a2 - NoH ) * NoH + 1;	// 2 mad
	return a2 / ( UNITY_PI * d * d + 1e-5f);					// 4 mul, 1 rcp

	////GGX [Walter et al. 2007, "Microfacet models for refraction through rough surfaces"]
	//float NoH2 = NoH * NoH;
	//float d = NoH2 * (a2 + (1 - NoH2) / NoH2);
	//return a2 / (UNITY_PI * d * d + 1e-5f);
}


float D_Gaussian(float Roughness, float NoH)
{
	float a = Roughness * Roughness;
	float thetaH = acos(NoH);
	return exp(-thetaH * thetaH / a);
}

Aniso-D

//-----------------------------------------------------------------------------
// Aniso D Iterm
//-----------------------------------------------------------------------------
// X -> roughness in tangent direction
// Y -> roughness in bitangent direction

// Anisotropic GGX
// [Burley 2012, "Physically-Based Shading at Disney"]
float D_GGXaniso( float RoughnessX, float RoughnessY, float NoH, float3 H, float3 X, float3 Y )
{
	float ax = RoughnessX * RoughnessX;
	float ay = RoughnessY * RoughnessY;
	float XoH = dot( X, H );
	float YoH = dot( Y, H );
	float d = XoH*XoH / (ax*ax) + YoH*YoH / (ay*ay) + NoH*NoH;
	return 1 / ( PI * ax*ay * d*d );
}

float D_WardAniso(float RoughnessX, float RoughnessY, float NoL, float NoV, float NoH, float3 H, float3 X, float3 Y)
{
	float ax = RoughnessX * RoughnessX;
	float ay = RoughnessY * RoughnessY;
	float XoH = dot(X, H);
	float YoH = dot(Y, H);

	float d = ((XoH*XoH) / (ax*ax) + (YoH * YoH) / (ay*ay)) / (NoH * NoH);
	return exp(-d) / (4 * PI * ax * ay * sqrt(NoL * NoV));
}

G

//-----------------------------------------------------------------------------
// G Iterm
// 1 / ( 4 * NoV * NoL) ��������
//-----------------------------------------------------------------------------

float Vis_Implicit()
{
	return 0.25;
}

// [Neumann et al. 1999, "Compact metallic reflectance models"]
float Vis_Neumann( float NoV, float NoL )
{
	return 1 / ( 4 * max( NoL, NoV ) );
}

// [Kelemen 2001, "A microfacet based coupled specular-matte brdf model with importance sampling"]
// Kelemen-Szirmay-Kalos is an approximation to Cook-Torrance visibility term
// http://sirkan.iit.bme.hu/~szirmay/scook.pdf
float Vis_Kelemen( float VoH )
{
	// constant to prevent NaN
	return rcp( 4 * VoH * VoH + 1e-5);
}

//Modified Kelemen-Szirmay-Kalos which takes roughness into account, based on: http://www.filmicworlds.com/2014/04/21/optimizing-ggx-shaders-with-dotlh/ 
half Vis_ModifiedKelemen(half LdotH, half Roughness)
{
	//form Unity
	half c = 0.797884560802865; // c = sqrt(2 / Pi)
	half k = Roughness * Roughness * c;
	half gH = LdotH * (1-k) + k;
	half res = 1.0 / (gH * gH);
	return res / 4; //Unity -> UE4

	//float gH = NdotV * k + (1 - k);
	//return (gH * gH * NdotL)/( 4 * NdotL * NdotV);
}

//Schlick-GGX
// Tuned to match behavior of Vis_Smith
// [Schlick 1994, "An Inexpensive BRDF Model for Physically-Based Rendering"]
float Vis_Schlick( float Roughness, float NoV, float NoL )
{
	float k = Roughness * Roughness * 0.5;
	float Vis_SchlickV = NoV * (1 - k) + k;
	float Vis_SchlickL = NoL * (1 - k) + k;
	return 0.25 / ( Vis_SchlickV * Vis_SchlickL );
}

// Appoximation of joint Smith term for GGX
// [Heitz 2014, "Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs"]
float Vis_SmithJointApprox(float Roughness, float NoV, float NoL)
{
	float a = Roughness * Roughness;
	float Vis_SmithV = NoL * (NoV * (1 - a) + a);
	float Vis_SmithL = NoV * (NoL * (1 - a) + a);
	// Note: will generate NaNs with Roughness = 0.  MinRoughness is used to prevent this
	return 0.5 * rcp(Vis_SmithV + Vis_SmithL + 1e-5f);
}

// [Hammon 2017, "PBR Diffuse Lighting for GGX+Smith Microsurfaces"]
float Vis_SmithGGXCorrelatedFast(float Roughness, float NoV, float NoL) {
	return 0.5 / lerp(2.0 * NoL * NoV, NoL + NoV, Roughness);
}

//Schlick-Beckmann
//From Unity, Smith-Schlick derived for Beckmann
half Vis_SmithBeckmann( float Roughness, float NoV, float NoL )
{
	half c = 0.797884560802865h; // c = sqrt(2 / Pi)
    half k = Roughness * c;

	float Vis_SchlickV = NoV * (1 - k) + k;
	float Vis_SchlickL = NoL * (1 - k) + k;
	return 0.25 / ( Vis_SchlickV * Vis_SchlickL + 1e-5f);
}

// Smith term for GGX
// [Smith 1967, "Geometrical shadowing of a random rough surface"]
float Vis_Smith( float Roughness, float NoV, float NoL )
{
	float a = Roughness * Roughness;
	float a2 = a*a;

	float Vis_SmithV = NoV + sqrt( NoV * (NoV - NoV * a2) + a2 );
	float Vis_SmithL = NoL + sqrt( NoL * (NoL - NoL * a2) + a2 );
	return 1/( Vis_SmithV * Vis_SmithL );

	//float Vis_SmithV = NoV * sqrt(NoV * (NoV - NoV * a2) + a2);
	//float Vis_SmithL = NoL * sqrt(NoL * (NoL - NoL * a2) + a2);
	//return 1 / (Vis_SmithV + Vis_SmithL);
}

//[Walter et al. 2007, "Microfacet models for refraction through rough surfaces"]
float Vis_GGX(float Roughness, float NoV, float NoL)
{
	//https://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
	float a = Roughness * Roughness;
	float a2 = a * a;

	float d = a2 + (1 - a2) * NoV * NoV;
	//float G = (2 * NoV) / (NoV + sqrt(d));
	return 0.5 / ((NoV + sqrt(d)) * NoL);
}

// Torrance-Sparrow G term (from Cook-Torrance)
// Cook-Torrance visibility term, doesn't take roughness into account
half Vis_CookTorrance (half NdotV, half NdotL, half NdotH, half VdotH)
{
	VdotH += 1e-5f;
	half G = min (1.0, min (
		(2.0 * NdotH * NdotV) / VdotH,
		(2.0 * NdotH * NdotL) / VdotH));
	return G / (NdotL * NdotV + 1e-4f);

	//�Ż�
	//return min(1, 2 * (NdotH / VdotH) * min(NdotL, NdotV)) / (NdotL * NdotV + 1e-4f);
}

float Vis_Beckmann(float Roughness, float NoV, float NoL)
{
	half a = Roughness * Roughness;
	
	float G1;
    float a1 = NoV / ( a * sqrt(1.0f - NoV * NoV));
    if ( a1 >= 1.6f ) {  
        G1 = 1.0f;
    }
    else {
        float c2 = a1 * a1;
        G1 = (3.535f * a1 + 2.181f * c2) / ( 1 + 2.276f * a1 + 2.577f * c2);
    }
	
	float G2;
	float a2 = NoL / ( a * sqrt(1.0f - NoL * NoL));
    if ( a2 >= 1.6f ) {   
        G2 = 1.0f;
    }
	else {  
        float c2 = a2 * a2;
        G2 = (3.535f * a2 + 2.181f * c2) / ( 1 + 2.276f * a2 + 2.577f * c2);
    }
    
	return G1 * G2 / ( 4 * NoL* NoV );
}

aniso-G
 

//-----------------------------------------------------------------------------
// Aniso G Iterm
//-----------------------------------------------------------------------------
// Ref: https://cedec.cesa.or.jp/2015/session/ENG/14698.html The Rendering Materials of Far Cry 4
// Note: V = G / (4 * NdotL * NdotV)
float V_SmithJointGGXAniso(float TdotV, float BdotV, float NdotV, float TdotL, float BdotL, float NdotL, float roughnessT, float roughnessB)
{
    float aT = roughnessT;
    float aT2 = aT * aT;
    float aB = roughnessB;
    float aB2 = aB * aB;

    float lambdaV = NdotL * sqrt(aT2 * TdotV * TdotV + aB2 * BdotV * BdotV + NdotV * NdotV);
    float lambdaL = NdotV * sqrt(aT2 * TdotL * TdotL + aB2 * BdotL * BdotL + NdotL * NdotL);

    return 0.5 / (lambdaV + lambdaL);
}


// Inline D_GGXAniso() * V_SmithJointGGXAniso() together for better code generation.
float DV_SmithJointGGXAniso(float TdotH, float BdotH, float NdotH,
                            float TdotV, float BdotV, float NdotV,
                            float TdotL, float BdotL, float NdotL,
                            float roughnessT, float roughnessB, float partLambdaV)
{
    float aT2 = roughnessT * roughnessT;
    float aB2 = roughnessB * roughnessB;

    float  f = TdotH * TdotH / aT2 + BdotH * BdotH / aB2 + NdotH * NdotH;
    float2 D = float2(1, roughnessT * roughnessB * f * f); // Fraction without the constant (1/Pi)

    float lambdaV = NdotL * partLambdaV;
    float lambdaL = NdotV * sqrt(aT2 * TdotL * TdotL + aB2 * BdotL * BdotL + NdotL * NdotL);

    float2 G = float2(1, lambdaV + lambdaL);               // Fraction without the constant (0.5)

    return (INV_PI * 0.5) * (D.x * G.x) / (D.y * G.y);
}

F

//-----------------------------------------------------------------------------
// Fresnel term
//-----------------------------------------------------------------------------

float3 F_None( float3 SpecularColor )
{
	return SpecularColor;
}

half3 F_Schlick(half3 f0, half3 f90, half VoH)
{
    half x  = 1.0 - VoH;
    half x2 = x * x;
    half x5 = x * x2 * x2;
    return f0 * (1.0 - x5) + (f90 * x5);        // sub mul mul mul sub mul mad*3

	// Anything less than 2% is physically impossible and is instead considered to be shadowing
	//return saturate( 50.0 * SpecularColor.g ) * Fc + (1 - Fc) * SpecularColor;
}

// [Schlick 1994, "An Inexpensive BRDF Model for Physically-Based Rendering"]
half3 F_Schlick(half3 f0, half VoH)
{
    return F_Schlick(f0, 1.0, VoH);               // sub mul mul mul sub mad
}

//Cook and Torrance 1982, "A Reflectance Model for Computer Graphics"
float3 F_CookTorrance( float3 SpecularColor, float VoH )
{
	//F02Ior
	float3 SpecularColorSqrt = sqrt( clamp( float3(0, 0, 0), float3(0.99, 0.99, 0.99), SpecularColor ) );
	float3 n = ( 1 + SpecularColorSqrt ) / ( 1 - SpecularColorSqrt ); 
	//fresnel
	float3 g = sqrt( n*n + VoH*VoH - 1 );
	return 0.5 * Square( (g - VoH) / (g + VoH) ) * ( 1 + Square( ((g+VoH)*VoH - 1) / ((g-VoH)*VoH + 1) ) );
}

// Ref: https://seblagarde.wordpress.com/2013/04/29/memo-on-fresnel-equations/
// Fresnel dieletric / conductor
// Note: etak2 = etak * etak (optimization for Artist Friendly Metallic Fresnel below)
// eta = eta_t / eta_i and etak = k_t / n_i
float3 F_FresnelConductor(float3 eta, float3 etak2, float cosTheta)
{
	float cosTheta2 = cosTheta * cosTheta;
	float sinTheta2 = 1.0 - cosTheta2;
	float3 eta2 = eta * eta;

	float3 t0 = eta2 - etak2 - sinTheta2;
	float3 a2plusb2 = sqrt(t0 * t0 + 4.0 * eta2 * etak2);
	float3 t1 = a2plusb2 + cosTheta2;
	float3 a = sqrt(0.5 * (a2plusb2 + t0));
	float3 t2 = 2.0 * a * cosTheta;
	float3 Rs = (t1 - t2) / (t1 + t2);

	float3 t3 = cosTheta2 * a2plusb2 + sinTheta2 * sinTheta2;
	float3 t4 = t2 * sinTheta2;
	float3 Rp = Rs * (t3 - t4) / (t3 + t4);

	return 0.5 * (Rp + Rs);
}

half3 F_SchlickApproximation(half3 f0, half NoH)
{
//	Fresnel: Schlick / fast fresnel approximation
	#define OneOnLN2_x6 8.656170
	return f0 + ( 1.0h - f0) * exp2(-OneOnLN2_x6 * NoH );
}

half F_SebastienLagarde(half VoH)
{
    return exp2((-5.55473h * VoH - 6.98316h) * VoH);
}

half F_SphericalGaussian(half3 F0, half VoH)
{
	return F0 + (1 - F0)  * pow(2, ((-5.55473 * VoH) - 6.98316) * VoH);
}

half3 F_LazarovFresnelTerm (half3 F0, half roughness, half VoH)
{
	half t = Pow5 (1 - VoH);	// ala Schlick interpoliation
	t /= 4 - 3 * roughness;
	return F0 + (1-F0) * t;
}
half3 F_SebLagardeFresnelTerm (half3 F0, half roughness, half VoH)
{
	half t = Pow5 (1 - VoH);	// ala Schlick interpoliation
	return F0 + (max (F0, roughness) - F0) * t;
}

f0

//---------------------
// F0 / IOR
//---------------------

float Ior2F0(float ior) 
{
	const float incidentIor = 1;
	float r = (ior - incidentIor) / (ior + incidentIor);
	return r * r;
}

float F02Ior(float f0) 
{
	float r = sqrt(f0);
	return (1.0 + r) / (1.0 - r);
}

other

//---------------
// EnvBRDF
//---------------

sampler2D		PreIntegratedGF;

half3 EnvBRDF( half3 SpecularColor, half Roughness, half NoV )
{
	// Importance sampled preintegrated G * F
	float2 AB = tex2D( PreIntegratedGF, float2( NoV, Roughness )).rg;

	// Anything less than 2% is physically impossible and is instead considered to be shadowing 
	float3 GF = SpecularColor * AB.x + saturate( 50.0 * SpecularColor.g ) * AB.y;
	return GF;
}

half3 EnvBRDFApprox( half3 SpecularColor, half Roughness, half NoV )
{
	// [ Lazarov 2013, "Getting More Physical in Call of Duty: Black Ops II" ]
	// Adaptation to fit our G term.
	const half4 c0 = { -1, -0.0275, -0.572, 0.022 };
	const half4 c1 = { 1, 0.0425, 1.04, -0.04 };
	half4 r = Roughness * c0 + c1;
	half a004 = min( r.x * r.x, exp2( -9.28 * NoV ) ) * r.x + r.y;
	half2 AB = half2( -1.04, 1.04 ) * a004 + r.zw;

#if !(ES2_PROFILE || ES3_1_PROFILE)
	// Anything less than 2% is physically impossible and is instead considered to be shadowing
	// In ES2 this is skipped for performance as the impact can be small
	// Note: this is needed for the 'specular' show flag to work, since it uses a SpecularColor of 0
	AB.y *= saturate( 50.0 * SpecularColor.g );
#endif

	return SpecularColor * AB.x + AB.y;
}

half EnvBRDFApproxNonmetal( half Roughness, half NoV )
{
	// Same as EnvBRDFApprox( 0.04, Roughness, NoV )
	const half2 c0 = { -1, -0.0275 };
	const half2 c1 = { 1, 0.0425 };
	half2 r = Roughness * c0 + c1;
	return min( r.x * r.x, exp2( -9.28 * NoV ) ) * r.x + r.y;
}

//-----------------------------------------------------------------------------
// D_Inv Iterm for Cloth
//-----------------------------------------------------------------------------

float D_InvBlinn( float Roughness, float NoH )
{
	float m = Roughness * Roughness;
	float m2 = m * m;
	float A = 4;
	float Cos2h = NoH * NoH;
	float Sin2h = 1 - Cos2h;
	//return rcp( PI * (1 + A*m2) ) * ( 1 + A * ClampedPow( Sin2h, 1 / m2 - 1 ) );
	return rcp( PI * (1 + A*m2) ) * ( 1 + A * exp( -Cos2h / m2 ) );
}

float D_InvBeckmann( float Roughness, float NoH )
{
	float m = Roughness * Roughness;
	float m2 = m * m;
	float A = 4;
	float Cos2h = NoH * NoH;
	float Sin2h = 1 - Cos2h;
	float Sin4h = Sin2h * Sin2h;
	return rcp( PI * (1 + A*m2) * Sin4h ) * ( Sin4h + A * exp( -Cos2h / (m2 * Sin2h) ) );
}

// Neubelt and Pettineo 2013, "Crafting a Next-gen Material Pipeline for The Order: 1886"
float D_InvGGX( float Roughness, float NoH )
{
	float a = Roughness * Roughness;
	float a2 = a * a;
	float A = 4;
	float d = ( NoH - a2 * NoH ) * NoH + a2;
	return rcp( PI * (1 + A*a2) ) * ( 1 + 4 * a2*a2 / ( d*d ) );
}

// Ashikhmin 2007, "Distribution-based BRDFs"
float D_Ashikhmin(float Roughness, float NoH) {
	float a2 = Roughness * Roughness;
	float cos2h = NoH * NoH;
	float sin2h = max(1.0 - cos2h, 0.0078125); // 2^(-14/2), so sin2h^2 > 0 in fp16
	float sin4h = sin2h * sin2h;
	float cot2 = -cos2h / (a2 * sin2h);
	return 1.0 / (PI * (4.0 * a2 + 1.0) * sin4h) * (4.0 * exp(cot2) + sin4h);
}

// Estevez and Kulla 2017, "Production Friendly Microfacet Sheen BRDF"
float D_Charlie(float Roughness, float NoH) {
	float invAlpha = 1.0 / Roughness;
	float cos2h = NoH * NoH;
	float sin2h = max(1.0 - cos2h, 0.0078125); // 2^(-14/2), so sin2h^2 > 0 in fp16
	return (2.0 + invAlpha) * pow(sin2h, invAlpha * 0.5) / (2.0 * PI);
}

// Neubelt and Pettineo 2013, "Crafting a Next-gen Material Pipeline for The Order: 1886"
float Vis_Cloth(float NoV, float NoL) //Vis_Neubelt
{
	return rcp(4 * (NoL + NoV - NoL * NoV));
}

//from : Unity3D
float CharlieL(float x, float r)
{
	r = saturate(r);
	r = 1.0 - (1.0 - r) * (1.0 - r);

	float a = lerp(25.3245, 21.5473, r);
	float b = lerp(3.32435, 3.82987, r);
	float c = lerp(0.16801, 0.19823, r);
	float d = lerp(-1.27393, -1.97760, r);
	float e = lerp(-4.85967, -4.32054, r);

	return a / (1. + b * pow(abs(x), c) ) + d * x + e;
}

// Note: This version don't include the softening of the paper: Production Friendly Microfacet Sheen BRDF
float Vis_Charlie(float NdotL, float NdotV, float roughness)
{
	float lambdaV = NdotV < 0.5 ? exp(CharlieL(NdotV, roughness)) : exp(2.0 * CharlieL(0.5, roughness) - CharlieL(1.0 - NdotV, roughness));
	float lambdaL = NdotL < 0.5 ? exp(CharlieL(NdotL, roughness)) : exp(2.0 * CharlieL(0.5, roughness) - CharlieL(1.0 - NdotL, roughness));

	return 1.0 / ((1.0 + lambdaV + lambdaL) * (4.0 * NdotV * NdotL));
}

#endif //__BRDF_CGINC__

【PBR系列五】镜面反射BRDF模型(Specular BRDF)及实现效果
qq_35312463的博客
08-21 8871
目前业界广泛采用的Microfacet Cook-Torrance BRDF形式如下： 其中： D(h) : 法线分布函数 （Normal Distribution Function），描述微面元法线分布的概率，即正确朝向的法线的浓度。即具有正确朝向，能够将来自l的光反射到v的表面点的相对于表面面积的浓度。 F(l,h) : 菲涅尔方程（Fresnel Equation），描述不同的表面角下表面所反射的光线所占的比率。 G(l,v,h) : 几何函数（Geometry Function），描述微平面自
UnityShader 基础光照模型-完整版（The Basic Lighting Model）
Unity3D Unreal
12-16 2621
本文分别介绍了两种漫反射光照模型（兰伯特和半兰伯特）、两种镜面反射模型（Phong和Blinn-phong）自发光、环境光等理论基础和在unity中的计算方式。详细介绍了这些光照在逐顶点光照模型中和逐像素光照模型中的完整计算。附带完整代码和最终渲染图。解析逐顶点光照模型和逐像素光照模型的区别。一、基础光照模型（在基础光照模型中，物体的表面颜色是自发光、环境光、漫反射、镜面反射的总和。即surfaceColor = emissive + ambient + diffuse + specula。展示了实现过程。
URP绸缎材质近似
jianfei_zhou的博客
03-07 5945
URP绸缎材质近似
4种基本光照模型
刀客
05-12 9929
1.Lambert模型(漫反射) 环境光： Iambdiff = Kd*Ia 其中Ia 表示环境光强度，Kd(0<K<1)为材质对环境光的反射系数，Iambdiff是漫反射体与环境光交互反射的光强。 方向光： Ildiff = Kd * Il * Cos(θ) 其中Il是点光源强度，θ是入射光方向与顶点法线的夹角，称入射角(0<=A<=90°)，Ildiff是漫反射体与方向光交互反射的光强，若 N为顶点单位法向量，L表示从顶点指向光源的单位向量(注意顶点指向光源)，则Co
Unity 中的基础光照
九本才的博客
01-27 2746
通常来讲，我们要模拟真实的光照环境来生成一张图像，需要考虑三种物理现象。 首先，光线从光源中被发射出来。 然后，光线和场景中的一些物体相交：一些光被物体吸收了，而另一些光被散射到其他方向。 最后，摄像机吸收了一些光，产生了一张图像。 光源 在实时渲染中，我们通常把光源当成一个没有体积的点，用L 来表示她的方向。那么，我们如何测量一个光源发射出多少光呢？也就是说，我们如何量化光，在光学里，我们使用辐照度来量化光。对于平行光来说，他的辐照度可通过计算在垂直于L的单位面积上单位时间穿过的能量来得到。在计
PBR物理材质
现在学习也不晚
06-23 1245
本人笔记，不喜勿喷PBR在英文里面是 Physically Based Rendering 翻译成中文就是基于物理的渲染。
Unity3D-Shader-自定义光照模型lighting model
游戏人生
01-28 1483
一个最常见的的光照模型例子 #pragma surface surf BasicDiffuse inline float4 LightingBasicDiffuse (SurfaceOutput s, fixed3 lightDir, fixed atten){ float difLight = max(0, dot (s.Normal, lightDir)); float4...
基础光照-Phong 光照模型
热门推荐
u014767384的博客
08-18 2万+
1. Phong 光照模型 1.1 环境光照 Ambient Lighting 1.1.1 实现代码 1.2 漫反射光照 Diffuse Lighting 1.2.1 法向量 及实现代码 1.2.2 计算漫反射光照 1.2.3 法向量 注意事项 1.3 镜面光照 Specular Lighting 2. 总结 1. Phong 光照模型 现实世界的光照是极其复杂...
精选资源
glo_纹理和光照模型_计算机图形学_bezier曲面OpenGL_bezier曲面光照_
09-29
在计算机图形学领域，纹理和光照模型是两个关键概念，它们极大地影响了图像的真实感和视觉效果。Bezier曲面作为非线性参数曲线和曲面的一种表示方式，广泛应用于3D建模和渲染中。本篇文章将深入探讨如何使用OpenGL库...
冯氏光照模型(Phong Lighting Model) 简单实现
阿豪
04-05 641
原文链接: 冯氏光照模型(Phong Lighting Model) 简单实现 ...
光照（Lighting）
06-30
3. **应用光照模型**：常见的光照模型有Lambertian、Phong或Blinn-Phong等。它们通过结合表面法线和光照向量来计算出最终的颜色贡献。 4. **混合材质颜色**：将光源颜色、物体表面颜色和环境颜色进行混合，得到最终...
OpenGL学习笔记（九）：初级光照：光照模型（环境光照、漫反射光照、镜面光照）
qq_39281631的博客
02-04 1163
现实世界的光照是极其复杂的，而且会受到诸多因素的影响，这是我们有限的计算能力所无法模拟的。因此OpenGL的光照使用的是简化的模型，对现实的情况进行近似，这样处理起来会更容易。
基于物理着色(PBS)及Unity中的实现
Mz
06-08 7471
Physically Based Shading
SCI复现含可再生能源与储能的区域微电网最优运行：应对不确定性的解鲁棒性与非预见性研究（Matlab代码实现）
最新发布
01-04
【SCI复现】含可再生能源与储能的区域微电网最优运行：应对不确定性的解鲁棒性与非预见性研究（Matlab代码实现）内容概要：本文围绕含可再生能源与储能的区域微电网最优运行展开研究，重点探讨应对不确定性的解鲁棒性与非预见性策略，通过Matlab代码实现SCI论文复现。研究涵盖多阶段鲁棒调度模型、机会约束规划、需求响应机制及储能系统优化配置，结合风电、光伏等可再生能源出力的不确定性建模，提出兼顾系统经济性与鲁棒性的优化运行方案。文中详细展示了模型构建、算法设计（如C&CG算法、大M法）及仿真验证全过程，适用于微电网能量管理、电力系统优化调度等领域的科研与工程实践。; 适合人群：具备一定电力系统、优化理论和Matlab编程基础的研究生、科研人员及从事微电网、能源管理相关工作的工程技术人员。; 使用场景及目标：①复现SCI级微电网鲁棒优化研究成果，掌握应对风光负荷不确定性的建模与求解方法；②深入理解两阶段鲁棒优化、分布鲁棒优化、机会约束规划等先进优化方法在能源系统中的实际应用；③为撰写高水平学术论文或开展相关课题研究提供代码参考和技术支持。; 阅读建议：建议读者结合文档提供的Matlab代码逐模块学习，重点关注不确定性建模、鲁棒优化模型构建与求解流程，并尝试在不同场景下调试与扩展代码，以深化对微电网优化运行机制的理解。
干辣椒粉，全球前10强生产商排名及市场份额（by QYResearch）.docx
01-04
干辣椒粉，全球前10强生产商排名及市场份额（by QYResearch）.docx
Adobe XD 2025（XD 58）安装教程及下载
01-04
Adobe XD 2025（XD 58）安装教程及下载
现代物流行业交通工具背景PPT模板
01-04
下载方式：https://pan.quark.cn/s/88340bbdd0a9 这是一套以交通工具为元素的，面向现代物流领域的PPT演示文稿模板，总共包含22页幻灯片。 模板的封面部分采用了多种蓝色及紫色色块进行装饰，并融合了若干物流运输工具，例如飞机、高速列车等作为视觉元素，用以构成背景设计，从而使得整个演示文稿模板与物流行业的主旨高度契合。 在内容页的设计上，模板继续运用蓝色与紫色进行色彩搭配，精心制作了20页采用扁平化设计的幻灯片图表。 此模板主要适用于构建物流行业相关的项目工作报告演示文稿。 文件存储格式为.PPTX。
个人防护装备实例分割数据集-20251118-012304.zip
01-04
个人防护装备实例分割数据集 一、基础信息 数据集名称：个人防护装备实例分割数据集 图片数量： 训练集：4,524张图片 分类类别： - Gloves（手套）：工作人员佩戴的手部防护装备。 - Helmet（安全帽）：头部防护装备。 - No-Gloves（未戴手套）：未佩戴手部防护的状态。 - No-Helmet（未戴安全帽）：未佩戴头部防护的状态。 - No-Shoes（未穿安全鞋）：未佩戴足部防护的状态。 - No-Vest（未穿安全背心）：未佩戴身体防护的状态。 - Shoes（安全鞋）：足部防护装备。 - Vest（安全背心）：身体防护装备。 标注格式：YOLO格式，包含实例分割的多边形坐标和类别标签，适用于实例分割任务。 数据格式：来源于实际场景图像，适用于计算机视觉模型训练。 二、适用场景 工作场所安全监控系统开发：数据集支持实例分割任务，帮助构建能够自动识别工作人员个人防护装备穿戴状态的AI模型，提升工作环境安全性。 建筑与工业安全检查：集成至监控系统，实时检测PPE穿戴情况，预防安全事故，确保合规性。 学术研究与创新：支持计算机视觉在职业安全领域的应用研究，促进AI与安全工程的结合。 培训与教育：可用于安全培训课程，演示PPE识别技术，增强员工安全意识。 三、数据集优势 精准标注与多样性：每个实例均用多边形精确标注，确保分割边界准确；覆盖多种PPE物品及未穿戴状态，增加模型鲁棒性。 场景丰富：数据来源于多样环境，提升模型在不同场景下的泛化能力。 任务适配性强：标注兼容主流深度学习框架（如YOLO），可直接用于实例分割模型开发，支持目标检测和分割任务。 实用价值高：专注于工作场所安全，为自动化的PPE检测提供可靠数据支撑，有助于减少工伤事故。
软件工程基于SVN的版本控制与CI/CD集成：计算机竞赛项目协同开发优化策略研究
01-04
内容概要：本文介绍了SVN版本控制系统在计算机竞赛中的高级应用，重点阐述了其与持续集成和持续部署（CI/CD）流程的结合使用，提升开发效率与代码质量。文章讲解了SVN的核心技巧，包括钩子脚本的使用、权限管理机制以及日志管理的重要性，并通过实际应用场景展示了其在大型竞赛项目、实时协作开发和成果展示中的价值。此外，提供了结合Jenkins实现自动化构建、测试与部署的详细代码案例，展示了从代码拉取到服务部署的完整流程。最后展望了SVN未来可能与人工智能、机器学习及区块链技术融合的发展趋势，增强智能化和安全性。; 适合人群：具备一定软件开发和版本控制基础，参与计算机竞赛或团队协作开发的1-3年经验研发人员或学生开发者； 使用场景及目标：①在竞赛团队中实现高效的代码协同与自动化集成；②通过SVN钩子与权限管理保障代码规范与安全；③利用日志与版本历史追踪开发进程并支持成果展示； 阅读建议：学习时应结合Jenkins等CI/CD工具进行实践操作，重点关注钩子脚本编写、自动化构建流程配置及权限策略设计，深入理解SVN在复杂项目中的工程化应用。
光照模型深入研究与开源探讨
局部光照模型因其计算效率相对较高，所以在实时渲染领域应用广泛，如冯氏光照模型（Phong Lighting Model），包括环境光（ambient）、漫反射（diffuse）和镜面反射（specular）三个组成部分。全局光照模型能够提供...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值