PBR Maths

src/Shaders/ShadersInclude/lightFragment.fx

@@ -4,13 +4,13 @@
     #else
 		#ifdef PBR
 			#ifdef SPOTLIGHT{X}
-				info = computeSpotLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDirection, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightDiffuse.a, roughness, NdotV, specularEnvironmentR90, NdotL);
+				info = computeSpotLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDirection, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightDiffuse.a, roughness, NdotV, specularEnvironmentR0, specularEnvironmentR90, NdotL);
 			#endif
 			#ifdef HEMILIGHT{X}
-				info = computeHemisphericLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightGround, roughness, NdotV, specularEnvironmentR90, NdotL);
+				info = computeHemisphericLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightGround, roughness, NdotV, specularEnvironmentR0, specularEnvironmentR90, NdotL);
 			#endif
 			#if defined(POINTLIGHT{X}) || defined(DIRLIGHT{X})
-				info = computeLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightDiffuse.a, roughness, NdotV, specularEnvironmentR90, NdotL);
+				info = computeLighting(viewDirectionW, normalW, light{X}.vLightData, light{X}.vLightDiffuse.rgb, light{X}.vLightSpecular, light{X}.vLightDiffuse.a, roughness, NdotV, specularEnvironmentR0, specularEnvironmentR90, NdotL);
 			#endif
 		#else
 			#ifdef SPOTLIGHT{X}
@@ -57,6 +57,7 @@
 	#else
 		shadow = 1.;
 	#endif
+
 	#ifdef CUSTOMUSERLIGHTING
 		diffuseBase += computeCustomDiffuseLighting(info, diffuseBase, shadow);
 		#ifdef SPECULARTERM

src/Shaders/ShadersInclude/pbrFunctions.fx

@@ -86,17 +86,16 @@ vec3 FresnelSchlickEnvironmentGGX(float VdotN, vec3 reflectance0, vec3 reflectan
 }
 
 // Cook Torance Specular computation.
-vec3 computeSpecularTerm(float NdotH, float NdotL, float NdotV, float VdotH, float roughness, vec3 specularColor, vec3 reflectance90)
+vec3 computeSpecularTerm(float NdotH, float NdotL, float NdotV, float VdotH, float roughness, vec3 reflectance0, vec3 reflectance90)
 {
     float alphaG = convertRoughnessToAverageSlope(roughness);
     float distribution = normalDistributionFunction_TrowbridgeReitzGGX(NdotH, alphaG);
     float visibility = smithVisibilityG_TrowbridgeReitzGGX_Walter(NdotL, NdotV, alphaG);
     visibility /= (4.0 * NdotL * NdotV); // Cook Torance Denominator  integated in viibility to avoid issues when visibility function changes.
-
-    vec3 fresnel = fresnelSchlickGGX(VdotH, specularColor, reflectance90);
-
     float specTerm = max(0., visibility * distribution) * NdotL;
-    return fresnel * specTerm * kPi; // TODO: audit pi constants
+
+    vec3 fresnel = fresnelSchlickGGX(VdotH, reflectance0, reflectance90);
+    return vec3(specTerm, specTerm, specTerm);
 }
 
 float computeDiffuseTerm(float NdotL, float NdotV, float VdotH, float roughness)
@@ -106,14 +105,11 @@ float computeDiffuseTerm(float NdotL, float NdotV, float VdotH, float roughness)
     float diffuseFresnelNV = pow(clamp(1.0 - NdotL, 0.000001, 1.), 5.0);
     float diffuseFresnelNL = pow(clamp(1.0 - NdotV, 0.000001, 1.), 5.0);
     float diffuseFresnel90 = 0.5 + 2.0 * VdotH * VdotH * roughness;
-    float diffuseFresnelTerm =
+    float fresnel =
         (1.0 + (diffuseFresnel90 - 1.0) * diffuseFresnelNL) *
         (1.0 + (diffuseFresnel90 - 1.0) * diffuseFresnelNV);
 
-
-    return diffuseFresnelTerm * NdotL;
-    // PI Test
-    // diffuseFresnelTerm /= kPi;
+    return fresnel * NdotL / kPi;
 }
 
 float adjustRoughnessFromLightProperties(float roughness, float lightRadius, float lightDistance)
@@ -131,7 +127,7 @@ float adjustRoughnessFromLightProperties(float roughness, float lightRadius, flo
 
 float computeDefaultMicroSurface(float microSurface, vec3 reflectivityColor)
 {
-    float kReflectivityNoAlphaWorkflow_SmoothnessMax = 0.95;
+    const float kReflectivityNoAlphaWorkflow_SmoothnessMax = 0.95;
 
     float reflectivityLuminance = getLuminance(reflectivityColor);
     float reflectivityLuma = sqrt(reflectivityLuminance);

src/Shaders/ShadersInclude/pbrLightFunctions.fx

@@ -10,7 +10,7 @@ struct lightingInfo
 float computeDistanceLightFalloff(vec3 lightOffset, float lightDistanceSquared, float range)
 {   
     #ifdef USEPHYSICALLIGHTFALLOFF
-        float lightDistanceFalloff = 1.0 / ((lightDistanceSquared + 0.0001));
+        float lightDistanceFalloff = 1.0 / ((lightDistanceSquared + 0.001));
     #else
         float lightDistanceFalloff = max(0., 1.0 - length(lightOffset) / range);
     #endif
@@ -48,7 +48,7 @@ float computeDirectionalLightFalloff(vec3 lightDirection, vec3 directionToLightC
     return falloff;
 }
 
-lightingInfo computeLighting(vec3 viewDirectionW, vec3 vNormal, vec4 lightData, vec3 diffuseColor, vec3 specularColor, float rangeRadius, float roughness, float NdotV, vec3 reflectance90, out float NdotL) {
+lightingInfo computeLighting(vec3 viewDirectionW, vec3 vNormal, vec4 lightData, vec3 diffuseColor, vec3 specularColor, float rangeRadius, float roughness, float NdotV, vec3 reflectance0, vec3 reflectance90, out float NdotL) {
     lightingInfo result;
 
     vec3 lightDirection;
@@ -77,24 +77,24 @@ lightingInfo computeLighting(vec3 viewDirectionW, vec3 vNormal, vec4 lightData,
     
     // diffuse
     vec3 H = normalize(viewDirectionW + lightDirection);
-    NdotL = max(0.00000000001, dot(vNormal, lightDirection));
-    float VdotH = clamp(0.00000000001, 1.0, dot(viewDirectionW, H));
+    NdotL = clamp(dot(vNormal, lightDirection), 0.00000000001, 1.0);
+    float VdotH = clamp(dot(viewDirectionW, H), 0.0, 1.0);
 
     float diffuseTerm = computeDiffuseTerm(NdotL, NdotV, VdotH, roughness);
     result.diffuse = diffuseTerm * diffuseColor * attenuation;
 
     #ifdef SPECULARTERM
         // Specular
-        float NdotH = max(0.00000000001, dot(vNormal, H));
+        float NdotH = clamp(dot(vNormal, H), 0.000000000001, 1.0);
 
-        vec3 specTerm = computeSpecularTerm(NdotH, NdotL, NdotV, VdotH, roughness, specularColor, reflectance90);
-        result.specular = specTerm * attenuation;
+        vec3 specTerm = computeSpecularTerm(NdotH, NdotL, NdotV, VdotH, roughness, reflectance0, reflectance90);
+        result.specular = specTerm * diffuseColor * attenuation;
     #endif
 
     return result;
 }
 
-lightingInfo computeSpotLighting(vec3 viewDirectionW, vec3 vNormal, vec4 lightData, vec4 lightDirection, vec3 diffuseColor, vec3 specularColor, float rangeRadius, float roughness, float NdotV, vec3 reflectance90, out float NdotL) {
+lightingInfo computeSpotLighting(vec3 viewDirectionW, vec3 vNormal, vec4 lightData, vec4 lightDirection, vec3 diffuseColor, vec3 specularColor, float rangeRadius, float roughness, float NdotV, vec3 reflectance0, vec3 reflectance90, out float NdotL) {
     lightingInfo result;
 
     vec3 lightOffset = lightData.xyz - vPositionW;
@@ -114,24 +114,24 @@ lightingInfo computeSpotLighting(vec3 viewDirectionW, vec3 vNormal, vec4 lightDa
     
     // Diffuse
     vec3 H = normalize(viewDirectionW + directionToLightCenterW);
-    NdotL = max(0.00000000001, dot(vNormal, directionToLightCenterW));
-    float VdotH = clamp(dot(viewDirectionW, H), 0.00000000001, 1.0);
+    NdotL = clamp(dot(vNormal, directionToLightCenterW), 0.000000000001, 1.0);
+    float VdotH = clamp(dot(viewDirectionW, H), 0.0, 1.0);
 
     float diffuseTerm = computeDiffuseTerm(NdotL, NdotV, VdotH, roughness);
     result.diffuse = diffuseTerm * diffuseColor * attenuation;
 
     #ifdef SPECULARTERM
         // Specular
-        float NdotH = max(0.00000000001, dot(vNormal, H));
+        float NdotH = clamp(dot(vNormal, H), 0.000000000001, 1.0);
 
-        vec3 specTerm = computeSpecularTerm(NdotH, NdotL, NdotV, VdotH, roughness, specularColor, reflectance90);
-        result.specular = specTerm  * attenuation;
+        vec3 specTerm = computeSpecularTerm(NdotH, NdotL, NdotV, VdotH, roughness, reflectance0, reflectance90);
+        result.specular = specTerm * diffuseColor * attenuation;
     #endif
 
     return result;
 }
 
-lightingInfo computeHemisphericLighting(vec3 viewDirectionW, vec3 vNormal, vec4 lightData, vec3 diffuseColor, vec3 specularColor, vec3 groundColor, float roughness, float NdotV, vec3 reflectance90, out float NdotL) {
+lightingInfo computeHemisphericLighting(vec3 viewDirectionW, vec3 vNormal, vec4 lightData, vec3 diffuseColor, vec3 specularColor, vec3 groundColor, float roughness, float NdotV, vec3 reflectance0, vec3 reflectance90, out float NdotL) {
     lightingInfo result;
 
     // Roughness
@@ -145,12 +145,12 @@ lightingInfo computeHemisphericLighting(vec3 viewDirectionW, vec3 vNormal, vec4
         // Specular
         vec3 lightVectorW = normalize(lightData.xyz);
         vec3 H = normalize(viewDirectionW + lightVectorW);
-        float NdotH = max(0.00000000001, dot(vNormal, H));
-        NdotL = max(0.00000000001, NdotL);
-        float VdotH = clamp(0.00000000001, 1.0, dot(viewDirectionW, H));
+        float NdotH = clamp(dot(vNormal, H), 0.000000000001, 1.0);
+        NdotL = clamp(NdotL, 0.000000000001, 1.0);
+        float VdotH = clamp(dot(viewDirectionW, H), 0.0, 1.0);
 
-        vec3 specTerm = computeSpecularTerm(NdotH, NdotL, NdotV, VdotH, roughness, specularColor, reflectance90);
-        result.specular = specTerm;
+        vec3 specTerm = computeSpecularTerm(NdotH, NdotL, NdotV, VdotH, roughness, reflectance0, reflectance90);
+        result.specular = specTerm * diffuseColor;
     #endif
 
     return result;

src/Shaders/pbr.fragment.fx

@@ -161,7 +161,7 @@ void main(void) {
 
 #ifdef ALBEDO
 	vec4 albedoTexture = texture2D(albedoSampler, vAlbedoUV + uvOffset);
-	#ifdef ALPHAFROMALBEDO
+	#if defined(ALPHAFROMALBEDO) || defined(ALPHATEST)
 		alpha *= albedoTexture.a;
 	#endif
 
@@ -264,13 +264,13 @@ void main(void) {
 #endif
 
 	// Compute N dot V.
-	float NdotV = max(0.00000000001, dot(normalW, viewDirectionW));
+	float NdotV = clamp(dot(normalW, viewDirectionW),0., 1.) + 0.00001;
 
 	// Adapt microSurface.
-	microSurface = clamp(microSurface, 0., 1.) * 0.98;
+	microSurface = clamp(microSurface, 0., 1.);
 
 	// Compute roughness.
-	float roughness = clamp(1. - microSurface, 0.000001, 1.0);
+	float roughness = 1. - microSurface;
 
 	#ifdef LIGHTMAP
   		vec3 lightmapColor = texture2D(lightmapSampler, vLightmapUV + uvOffset).rgb * vLightmapInfos.y;
@@ -518,7 +518,8 @@ void main(void) {
 	vec3 surfaceEmissiveColor = vEmissiveColor;
 #ifdef EMISSIVE
 	vec3 emissiveColorTex = texture2D(emissiveSampler, vEmissiveUV + uvOffset).rgb;
-	surfaceEmissiveColor = toLinearSpace(emissiveColorTex.rgb) * surfaceEmissiveColor * vEmissiveInfos.y;
+	surfaceEmissiveColor = toLinearSpace(emissiveColorTex.rgb) * surfaceEmissiveColor;
+	surfaceEmissiveColor *=  vEmissiveInfos.y;
 #endif
 
 #ifdef EMISSIVEFRESNEL
@@ -580,8 +581,6 @@ vec4 finalColor = vec4(finalDiffuse + finalSpecular + environmentRadiance + refr
 	finalColor.rgb = toneMaps(finalColor.rgb);
 #endif
 
-	finalColor.rgb = toGammaSpace(finalColor.rgb);
-
 #include<logDepthFragment>
 #include<fogFragment>(color, finalColor)
 
@@ -590,6 +589,8 @@ vec4 finalColor = vec4(finalDiffuse + finalSpecular + environmentRadiance + refr
 #endif
 
 #ifdef LDROUTPUT
+	finalColor.rgb = toGammaSpace(finalColor.rgb);
+
 	finalColor.rgb = clamp(finalColor.rgb, 0., 1.);
 
 	#ifdef CAMERACOLORGRADING
@@ -599,12 +600,16 @@ vec4 finalColor = vec4(finalDiffuse + finalSpecular + environmentRadiance + refr
 	#ifdef CAMERACOLORCURVES
 		finalColor.rgb = applyColorCurves(finalColor.rgb);
 	#endif
+#else
+	//sanitize output incase invalid normals or tangents have caused div by 0 or undefined behavior
+	//this also limits the brightness which helpfully reduces over-sparkling in bloom (native handles this in the bloom blur shader)
+	finalColor.rgb = clamp(finalColor.rgb, 0., 30.0);
 #endif
 
 	gl_FragColor = finalColor;
 
 	// Normal Display.
-	// gl_FragColor = vec4(normalW * 0.5 + 0.5, 1.0);
+	//gl_FragColor = vec4(normalW * 0.5 + 0.5, 1.0);
 
 	// Ambient reflection color.
 	// gl_FragColor = vec4(ambientReflectionColor, 1.0);
@@ -615,12 +620,24 @@ vec4 finalColor = vec4(finalDiffuse + finalSpecular + environmentRadiance + refr
 	// Base color.
 	// gl_FragColor = vec4(surfaceAlbedo.rgb, 1.0);
 
+	// Diffuse Direct Lighting
+	// gl_FragColor = vec4(diffuseBase.rgb, 1.0);
+
+	// Specular Lighting
+	// gl_FragColor = vec4(specularBase.rgb, 1.0);
+
+	// Final Specular
+	// gl_FragColor = vec4(finalSpecular.rgb, 1.0);
+
 	// Specular color.
 	// gl_FragColor = vec4(surfaceReflectivityColor.rgb, 1.0);
 
 	// MicroSurface color.
 	// gl_FragColor = vec4(microSurface, microSurface, microSurface, 1.0);
 
+	// Roughness.
+	// gl_FragColor = vec4(roughness, roughness, roughness, 1.0);
+
 	// Specular Map
 	// gl_FragColor = vec4(reflectivityMapColor.rgb, 1.0);