光照模型（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 8874
目前业界广泛采用的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 5947
URP绸缎材质近似
Unity 中的基础光照
九本才的博客
01-27 2747
通常来讲，我们要模拟真实的光照环境来生成一张图像，需要考虑三种物理现象。 首先，光线从光源中被发射出来。 然后，光线和场景中的一些物体相交：一些光被物体吸收了，而另一些光被散射到其他方向。 最后，摄像机吸收了一些光，产生了一张图像。 光源 在实时渲染中，我们通常把光源当成一个没有体积的点，用L 来表示她的方向。那么，我们如何测量一个光源发射出多少光呢？也就是说，我们如何量化光，在光学里，我们使用辐照度来量化光。对于平行光来说，他的辐照度可通过计算在垂直于L的单位面积上单位时间穿过的能量来得到。在计
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
基于物理着色(PBS)及Unity中的实现
Mz
06-08 7471
Physically Based Shading
Unity3D-Shader-自定义光照模型lighting model
游戏人生
01-28 1484
一个最常见的的光照模型例子 #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 1164
现实世界的光照是极其复杂的，而且会受到诸多因素的影响，这是我们有限的计算能力所无法模拟的。因此OpenGL的光照使用的是简化的模型，对现实的情况进行近似，这样处理起来会更容易。
PBR物理材质
现在学习也不晚
06-23 1245
本人笔记，不喜勿喷PBR在英文里面是 Physically Based Rendering 翻译成中文就是基于物理的渲染。
autobuild:基础构建系统，用于导入和构建软件包，基于Rock（机器人构建套件）的autoproj
01-04
先展示下效果 https://pan.quark.cn/s/e612e515c6cb 自动构建的定义是什么？ Autobuild是由与构建系统（例如，autotools，CMake）和导入机制（git，svn，...）相连接的类群组构成。 它被应用于开发更高级别的工具，这些工具提供了对整个工作区进行管理的功能。 为了安装此程序，需将这行代码加入到您的应用程序的Gemfile文件中：gem autobuild 随后执行：$ bundle或者将其自行安装为：$ gem install autobuild在签出存储库之后，执行bundle install来安装所依赖的组件。 接着，执行bundle exec rake test来执行测试操作。 若需将这个gem安装到本地设备上，请运行bundle exec rake install 。 当准备发布新版本时，应更新version.rb文件中的版本标识，然后运行bundle exec rake release ，该命令将为这一版本生成git标签，推送git的提交记录和标签。
PasswordGenerator: HTML/CSS/JavaScript制作的密码生成器
最新发布
01-04
下载前必看：https://pan.quark.cn/s/a4b39357ea24 ram-password 随机密码生成器
【无人机协同】动态环境下多无人机系统的协同路径规划与防撞研究（Matlab代码实现）​
01-04
【无人机协同】动态环境下多无人机系统的协同路径规划与防撞研究（Matlab代码实现）​ 内容概要：本文围绕动态环境下多无人机系统的协同路径规划与防撞问题展开研究，提出基于Matlab代码实现的解决方案。研究重点在于设计适用于动态环境的路径规划算法，确保多无人机在复杂任务场景下能够高效协同飞行并有效避免碰撞。文中结合智能优化算法与路径规划技术，探讨了无人机编队、任务分配及实时避障策略，通过Matlab仿真验证所提方法的有效性与鲁棒性，为多无人机系统在实际应用场景中的部署提供了技术支持和理论依据。; 适合人群：具备一定Matlab编程基础，从事无人机控制、路径规划或智能优化算法研究的科研人员及研究生。; 使用场景及目标：①应用于灾害救援、环境监测、物流配送等多无人机协同作业场景；②实现动态环境中无人机间的高效协同与安全避障，提升任务执行效率与系统安全性； 阅读建议：建议结合文中提供的Matlab代码进行仿真实践，深入理解算法实现细节，并可根据具体应用场景调整参数或扩展功能以满足实际需求。
Bottle Fin实例分割数据集-20251117-165640.zip
01-04
一、基础信息 数据集名称：Bottle Fin实例分割数据集 图片数量： 训练集：4418张图片 验证集：1104张图片 总计：5522张图片 分类类别： - 类别0: 数字0 - 类别1: 数字1 - 类别2: 数字2 - 类别3: 数字3 - 类别4: 数字4 - 类别5: 数字5 - 类别6: Bottle Fin 标注格式：YOLO格式，包含多边形坐标，适用于实例分割任务。 数据格式：图片格式常见如JPEG或PNG，具体未指定。 二、适用场景 实例分割AI模型开发：数据集支持实例分割任务，帮助构建能够精确识别和分割图像中多个对象的AI模型，适用于对象检测和分割应用。 工业自动化与质量控制：可能应用于制造、物流或零售领域，用于自动化检测和分类物体，提升生产效率。 计算机视觉研究：支持实例分割算法的学术研究，促进目标检测和分割技术的创新。 教育与实践培训：可用于高校或培训机构的计算机视觉课程，作为实例分割任务的实践资源，帮助学生理解多类别分割。 三、数据集优势 多类别设计：包含7个不同类别，涵盖数字和Bottle Fin对象，增强模型对多样对象的识别和分割能力。 高质量标注：标注采用YOLO格式的多边形坐标，确保分割边界的精确性，提升模型训练效果。 数据规模适中：拥有超过5500张图片，提供充足的样本用于模型训练和验证，支持稳健的AI开发。 即插即用兼容性：标注格式直接兼容主流深度学习框架（如YOLO），便于快速集成到各种实例分割项目中。
基于Python与Qt的产品管理应用.zip
01-04
基于Python与Qt的产品管理应用
【计算机视觉】基于Deformable LKA的YOLOv8改进：目标检测精度与效率协同优化模型设计
01-04
内容概要：本文详细介绍了如何将Deformable LKA注意力模块嵌入YOLOv8目标检测模型，以提升其在复杂场景下的检测精度与效率。Deformable LKA结合了可变形卷积和大核注意力（LKA）的优势，前者使卷积核能自适应目标形状，后者通过大核捕获更广的全局特征并降低计算开销。文章提供了完整的实现步骤，包括环境搭建、模块代码实现、YOLOv8主干网络的修改方式以及训练和验证方法，并通过实验表明该改进在COCO数据集上显著提升了mAP（+3.3%），仅轻微降低推理速度。此外还给出了实际应用中的关键调参建议和适配场景。; 适合人群：具备一定深度学习基础，熟悉PyTorch框架，从事计算机视觉或目标检测相关工作的研究人员或工程师（工作1-3年为佳）； 使用场景及目标：①提升YOLOv8对变形目标、小目标的检测能力；②在精度与速度之间取得更好平衡；③掌握先进注意力机制的设计思想与工程实现方法； 阅读建议：建议结合飞书链接中的完整代码包进行实践操作，重点关注模块维度匹配、偏移量初始化等细节，确保顺利集成与训练。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值