Update the implementation of DiffuseGGX()

EvgeniiG · EvgeniiG · commit 52473b5fefb0 · 2017-03-31T15:25:56.000+02:00
diff --git a/Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl b/Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl
@@ -693,11 +693,11 @@ void BSDF(  float3 V, float3 L, float3 positionWS, PreLightData preLightData, BS
         bsdfData.roughnessB = ClampRoughnessForAnalyticalLights(bsdfData.roughnessB);
 
         #ifdef LIT_USE_BSDF_PRE_LAMBDAV
-        Vis = V_SmithJointGGXAnisoLambdaV(  preLightData.TdotV, preLightData.BdotV, preLightData.NdotV, TdotL, BdotL, NdotL,
+        Vis = V_SmithJointGGXAnisoLambdaV(  preLightData.TdotV, preLightData.BdotV, NdotV, TdotL, BdotL, NdotL,
                                             bsdfData.roughnessT, bsdfData.roughnessB, preLightData.anisoGGXLambdaV);
         #else
         // TODO: Do comparison between this correct version and the one from isotropic and see if there is any visual difference
-        Vis = V_SmithJointGGXAniso( preLightData.TdotV, preLightData.BdotV, preLightData.NdotV, TdotL, BdotL, NdotL,
+        Vis = V_SmithJointGGXAniso( preLightData.TdotV, preLightData.BdotV, NdotV, TdotL, BdotL, NdotL,
                                     bsdfData.roughnessT, bsdfData.roughnessB);
         #endif
 
@@ -708,18 +708,22 @@ void BSDF(  float3 V, float3 L, float3 positionWS, PreLightData preLightData, BS
         bsdfData.roughness = ClampRoughnessForAnalyticalLights(bsdfData.roughness);
 
         #ifdef LIT_USE_BSDF_PRE_LAMBDAV
-        Vis = V_SmithJointGGX(NdotL, preLightData.NdotV, bsdfData.roughness, preLightData.ggxLambdaV);
+        Vis = V_SmithJointGGX(NdotL, NdotV, bsdfData.roughness, preLightData.ggxLambdaV);
         #else
-        Vis = V_SmithJointGGX(NdotL, preLightData.NdotV, bsdfData.roughness);
+        Vis = V_SmithJointGGX(NdotL, NdotV, bsdfData.roughness);
         #endif
         D = D_GGX(NdotH, bsdfData.roughness);
     }
     specularLighting = F * (Vis * D);
-    #ifdef LIT_DIFFUSE_LAMBERT_BRDF
-    float diffuseTerm = Lambert();
-    #else
-    float diffuseTerm = DisneyDiffuse(preLightData.NdotV, NdotL, LdotH, bsdfData.perceptualRoughness);
-    #endif
+
+#ifdef LIT_DIFFUSE_LAMBERT_BRDF
+    float  diffuseTerm = Lambert();
+#elif LIT_DIFFUSE_GGX_BRDF
+    float3 diffuseTerm = DiffuseGGX(bsdfData.diffuseColor, NdotV, NdotL, NdotH, LdotV, bsdfData.perceptualRoughness);
+#else
+    float  diffuseTerm = DisneyDiffuse(NdotV, NdotL, LdotH, bsdfData.perceptualRoughness);
+#endif
+
     diffuseLighting = bsdfData.diffuseColor * diffuseTerm;
 }
 
diff --git a/Assets/ScriptableRenderPipeline/ShaderLibrary/BSDF.hlsl b/Assets/ScriptableRenderPipeline/ShaderLibrary/BSDF.hlsl
@@ -227,22 +227,25 @@ float DisneyDiffuse(float NdotV, float NdotL, float LdotH, float perceptualRough
 }
 
 // Ref: Diffuse Lighting for GGX + Smith Microsurfaces, p. 113.
-float3 DiffuseGGXNoPI(float3 albedo, float NdotV, float NdotL, float NdotH, float LdotV, float roughness)
+float3 DiffuseGGXNoPI(float3 albedo, float NdotV, float NdotL, float NdotH, float LdotV, float perceptualRoughness)
 {
     float facing    = 0.5 + 0.5 * LdotV;
     float rough     = facing * (0.9 - 0.4 * facing) * ((0.5 + NdotH) / NdotH);
     float transmitL = 1 - F_Schlick(0, 1, NdotL);
     float transmitV = 1 - F_Schlick(0, 1, NdotV);
-    float smooth    = transmitL * transmitV * 1.05;   // Normalize F_t over the hemisphere
-    float single    = lerp(smooth, rough, roughness); // Rescaled by PI
-    float multi     = roughness * (0.1159 * PI);      // Rescaled by PI
+    float smooth    = transmitL * transmitV * 1.05;             // Normalize F_t over the hemisphere
+    float single    = lerp(smooth, rough, perceptualRoughness); // Rescaled by PI
+    // This constant is picked s.t. setting perceptualRoughness, albedo and all angles to 1
+    // allows us to match the Lambertian and the Disney Diffuse models. Original value: 0.1159.
+    float multiple  = perceptualRoughness * (0.079577 * PI);    // Rescaled by PI
 
-    return single + albedo * multi;
+    return single + albedo * multiple;
 }
 
-float3 DiffuseGGX(float3 albedo, float NdotV, float NdotL, float NdotH, float LdotV, float roughness)
+float3 DiffuseGGX(float3 albedo, float NdotV, float NdotL, float NdotH, float LdotV, float perceptualRoughness)
 {
-    return INV_PI * DiffuseGGXNoPI(albedo, NdotV, NdotL, NdotH, LdotV, roughness);
+    // Note that we could save 2 cycles by inlining the multiplication by INV_PI.
+    return INV_PI * DiffuseGGXNoPI(albedo, NdotV, NdotL, NdotH, LdotV, perceptualRoughness);
 }
 
 #endif // UNITY_BSDF_INCLUDED

Original file line number	Diff line number	Diff line change
`@@ -227,22 +227,25 @@ float DisneyDiffuse(float NdotV, float NdotL, float LdotH, float perceptualRough`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`// Ref: Diffuse Lighting for GGX + Smith Microsurfaces, p. 113.`
`230`		`-float3 DiffuseGGXNoPI(float3 albedo, float NdotV, float NdotL, float NdotH, float LdotV, float roughness)`
	`230`	`+float3 DiffuseGGXNoPI(float3 albedo, float NdotV, float NdotL, float NdotH, float LdotV, float perceptualRoughness)`
`231`	`231`	`{`
`232`	`232`	`float facing = 0.5 + 0.5 * LdotV;`
`233`	`233`	`float rough = facing * (0.9 - 0.4 * facing) * ((0.5 + NdotH) / NdotH);`
`234`	`234`	`float transmitL = 1 - F_Schlick(0, 1, NdotL);`
`235`	`235`	`float transmitV = 1 - F_Schlick(0, 1, NdotV);`
`236`		`- float smooth = transmitL * transmitV * 1.05; // Normalize F_t over the hemisphere`
`237`		`- float single = lerp(smooth, rough, roughness); // Rescaled by PI`
`238`		`- float multi = roughness * (0.1159 * PI); // Rescaled by PI`
	`236`	`+ float smooth = transmitL * transmitV * 1.05; // Normalize F_t over the hemisphere`
	`237`	`+ float single = lerp(smooth, rough, perceptualRoughness); // Rescaled by PI`
	`238`	`+ // This constant is picked s.t. setting perceptualRoughness, albedo and all angles to 1`
	`239`	`+ // allows us to match the Lambertian and the Disney Diffuse models. Original value: 0.1159.`
	`240`	`+ float multiple = perceptualRoughness * (0.079577 * PI); // Rescaled by PI`
`239`	`241`
`240`		`- return single + albedo * multi;`
	`242`	`+ return single + albedo * multiple;`
`241`	`243`	`}`
`242`	`244`
`243`		`-float3 DiffuseGGX(float3 albedo, float NdotV, float NdotL, float NdotH, float LdotV, float roughness)`
	`245`	`+float3 DiffuseGGX(float3 albedo, float NdotV, float NdotL, float NdotH, float LdotV, float perceptualRoughness)`
`244`	`246`	`{`
`245`		`- return INV_PI * DiffuseGGXNoPI(albedo, NdotV, NdotL, NdotH, LdotV, roughness);`
	`247`	`+ // Note that we could save 2 cycles by inlining the multiplication by INV_PI.`
	`248`	`+ return INV_PI * DiffuseGGXNoPI(albedo, NdotV, NdotL, NdotH, LdotV, perceptualRoughness);`
`246`	`249`	`}`
`247`	`250`
`248`	`251`	`#endif // UNITY_BSDF_INCLUDED`