IBL Math hardening

Author: riccardobl

jme3-core/src/main/resources/Common/IBL/IBLKernels.frag

@@ -6,7 +6,7 @@
 */
 #import "Common/ShaderLib/GLSLCompat.glsllib"
 #import "Common/IBL/Math.glsl"
-
+#import "Common/ShaderLib/Math.glsllib"
 in vec2 TexCoords;
 in vec3 LocalPos;
 
@@ -15,12 +15,12 @@ uniform float m_Roughness;
 uniform int m_FaceId;
 
 void brdfKernel(){
-    float NdotV=TexCoords.x;
-    float roughness=TexCoords.y;
+    float NdotV = Math_saturate(TexCoords.x);
+    float roughness = Math_saturate(TexCoords.y);
     float alpha = roughness * roughness;
 
     vec3 V;
-    V.x = sqrt(1.0 - NdotV*NdotV);
+    V.x = sqrt(Math_saturate(1.0 - NdotV * NdotV));
     V.y = 0.0;
     V.z = NdotV;
     float A = 0.0;
@@ -36,8 +36,9 @@ void brdfKernel(){
         float VdotH = max(dot(V, H), 0.0);
         if(NdotL > 0.0){
             float G = GeometrySmith(N, V, L, alpha);
-            float G_Vis = (G * VdotH) / (NdotH * NdotV);
-            float Fc = pow(1.0 - VdotH, 5.0);
+            float G_Vis = (G * VdotH) / max(NdotH * NdotV, IBL_EPSILON);
+            float oneMinusVdotH = 1.0 - Math_saturate(VdotH);
+            float Fc = oneMinusVdotH * oneMinusVdotH * oneMinusVdotH * oneMinusVdotH * oneMinusVdotH;
             A += (1.0 - Fc) * G_Vis;
             B += Fc * G_Vis;
         }
@@ -52,8 +53,8 @@ void irradianceKernel(){
     // the sample direction equals the hemisphere's orientation 
     vec3 N = normalize(LocalPos);
     vec3 irradiance = vec3(0.0); 
-    vec3 up = vec3(0.0, 1.0, 0.0);
-    vec3 right = cross(up, N);
+    vec3 up = abs(N.y) < 0.999 ? vec3(0.0, 1.0, 0.0) : vec3(1.0, 0.0, 0.0);
+    vec3 right = normalize(cross(up, N));
     up = cross(N, right);
     float sampleDelta = 0.025;
     float nrSamples = 0.0; 
@@ -72,7 +73,7 @@ void irradianceKernel(){
 }
 
 void prefilteredEnvKernel(){		
-    vec3 N = normalize(LocalPos);    
+    vec3 N = normalize(LocalPos);
     vec3 R = N;
     vec3 V = R;
 

jme3-core/src/main/resources/Common/IBL/Math.glsl

@@ -4,6 +4,7 @@
 *               https://learnopengl.com/PBR/IBL/Specular-IBL
 *   - Riccardo Balbo
 */
+#import "Common/ShaderLib/Math.glsllib"
 const float PI = 3.14159265359;
 
 float RadicalInverse_VdC(uint bits) {
@@ -58,6 +59,9 @@ vec4 Hammersley(uint i, uint N){
 //
 // ImportanceSampleGGX() and GeometrySmith() both expect alpha.
 const float MIN_GGX_ALPHA = 0.0064;
+const float IBL_EPSILON = 1e-6;
+
+
 
 float SafeGGXAlpha(float alpha) {
     return max(alpha, MIN_GGX_ALPHA);
@@ -66,8 +70,8 @@ float SafeGGXAlpha(float alpha) {
 vec3 ImportanceSampleGGX(vec4 Xi, float alpha, vec3 N){
     alpha = SafeGGXAlpha(alpha);
     float alpha2 = alpha * alpha;
-    float cosTheta = sqrt((1.0 - Xi.y) / (1.0 + (alpha2 - 1.0) * Xi.y));
-    float sinTheta = sqrt(1.0 - cosTheta*cosTheta);
+    float cosTheta = sqrt(Math_saturate((1.0 - Xi.y) / (1.0 + (alpha2 - 1.0) * Xi.y)));
+    float sinTheta = sqrt(Math_saturate(1.0 - cosTheta * cosTheta));
 
     // from spherical coordinates to cartesian coordinates
     vec3 H;

jme3-core/src/main/resources/Common/IBLSphH/IBLSphH.frag

@@ -42,10 +42,11 @@ vec3 getVectorFromCubemapFaceTexCoord(float x, float y, float mapSize, int face)
 
 
     // Warp texel centers in the proximity of the edges.
-    float a = pow(mapSize, 2.0) / pow(mapSize - 1., 3.0);
+    float warpDenom = max(mapSize - 1.0, 1.0);
+    float a = (mapSize * mapSize) / (warpDenom * warpDenom * warpDenom);
 
-    u = a * pow(u, 3.) + u;
-    v = a * pow(v, 3.) + v;
+    u = a * u * u * u + u;
+    v = a * v * v * v + v;
     //compute vector depending on the face
     // Code from Nvtt : https://github.com/castano/nvidia-texture-tools/blob/master/src/nvtt/CubeSurface.cpp#L101
     vec3 o =vec3(0);

jme3-core/src/main/resources/Common/ShaderLib/Math.glsllib

@@ -18,5 +18,7 @@ void Math_lengthAndNormalize(in vec3 vec,out float outLength,out vec3 outNormal)
     outLength=invl*dotv;
 }
 
-
+float Math_saturate(float value) {
+    return clamp(value, 0.0, 1.0);
+}
 #endif

jme3-core/src/main/resources/Common/ShaderLib/PBR.glsllib

@@ -6,11 +6,28 @@
     #define NB_PROBES 0
 #endif
 
+#import "Common/ShaderLib/Math.glsllib"
 // Internal GGX stability floor. This does not change the user-facing
 // roughness convention or probe LOD mapping; it only prevents extremely sharp
 // microfacet lobes from reaching pathological peaks that can destabilize some
 // drivers and screenshot-test software renderers.
 const float MIN_GGX_ALPHA = 0.0064;
+const float PBR_EPSILON = 1e-6;
+
+float pbrNonZero(float value) {
+    if (abs(value) < PBR_EPSILON) {
+        return value < 0.0 ? -PBR_EPSILON : PBR_EPSILON;
+    }
+    return value;
+}
+
+vec3 pbrSafeReciprocal(vec3 value) {
+    return vec3(
+        1.0 / pbrNonZero(value.x),
+        1.0 / pbrNonZero(value.y),
+        1.0 / pbrNonZero(value.z)
+    );
+}
 
 // BEGIN-@jhonkkk,Specular AA --------------------------------------------------------------
 // see:http://www.jp.square-enix.com/tech/library/pdf/ImprovedGeometricSpecularAA(slides).pdf
@@ -165,16 +182,18 @@ vec3 ApproximateSpecularIBL(samplerCube envMap,sampler2D integrateBRDF, vec3 Spe
     // The specular bake stores roughness quadratically across mip levels:
     // mipNorm = mip / (nbMipMaps - 1), roughness = mipNorm * mipNorm.
     // Runtime therefore samples with sqrt(roughness) to recover mipNorm.
-    float Lod = sqrt( Roughness ) * (nbMipMaps - 1.0);
+    float roughness = Math_saturate(Roughness);
+    float Lod = sqrt(roughness) * max(nbMipMaps - 1.0, 0.0);
     vec3 PrefilteredColor =  textureCubeLod(envMap, refVec.xyz,Lod).rgb;
-    vec2 EnvBRDF = texture2D(integrateBRDF,vec2(ndotv, Roughness)).rg;
+    vec2 EnvBRDF = texture2D(integrateBRDF,vec2(Math_saturate(ndotv), roughness)).rg;
     return PrefilteredColor * ( SpecularColor * EnvBRDF.x+ EnvBRDF.y );    
 }
 
 vec3 ApproximateSpecularIBLPolynomial(samplerCube envMap, vec3 SpecularColor , float Roughness, float ndotv, vec3 refVec, float nbMipMaps){
-    float Lod = sqrt( Roughness ) * (nbMipMaps - 1.0);
+    float roughness = Math_saturate(Roughness);
+    float Lod = sqrt(roughness) * max(nbMipMaps - 1.0, 0.0);
     vec3 PrefilteredColor =  textureCubeLod(envMap, refVec.xyz, Lod).rgb;
-    return PrefilteredColor * integrateBRDFApprox(SpecularColor, Roughness, ndotv);
+    return PrefilteredColor * integrateBRDFApprox(SpecularColor, roughness, clamp(ndotv, 0.0, 1.0));
 }
 
 
@@ -203,7 +222,7 @@ float renderProbe(vec3 viewDir, vec3 worldPos, vec3 normal, vec3 norm, float Rou
         // mat3_sub our compat wrapper for mat3(mat4)
         mat3 wToLocalRot = inverse(mat3_sub(lightProbeData));
 
-        vec3 scale = vec3(lightProbeData[0][3], lightProbeData[1][3], lightProbeData[2][3]);
+        vec3 scale = max(abs(vec3(lightProbeData[0][3], lightProbeData[1][3], lightProbeData[2][3])), vec3(PBR_EPSILON));
         #if NB_PROBES >= 2
             // probe blending
             // compute fragment position in probe local space
@@ -223,8 +242,9 @@ float renderProbe(vec3 viewDir, vec3 worldPos, vec3 normal, vec3 norm, float Rou
         positionLs /= scale;
 
         vec3 unit = vec3(1.0);
-        vec3 firstPlaneIntersect = (unit - positionLs) / rayLs;
-        vec3 secondPlaneIntersect = (-unit - positionLs) / rayLs;
+        vec3 invRayLs = pbrSafeReciprocal(rayLs);
+        vec3 firstPlaneIntersect = (unit - positionLs) * invRayLs;
+        vec3 secondPlaneIntersect = (-unit - positionLs) * invRayLs;
         vec3 furthestPlane = max(firstPlaneIntersect, secondPlaneIntersect);
         float distance = min(min(furthestPlane.x, furthestPlane.y), furthestPlane.z);