Cleanup standard shaders (#510)

* Cleanup standard (blinn-phong) shader
* Updated unlit and standard PBR
* Updated lambert and added shadow clipping
* Fixed parallax mapping and fix feature set not supporting permutations
* Fixed material bool parameters not working
* Added option to clip edges after parallax pass
* Fixed normal mapping was using a TBN in right-handed coordinate system instead of left-handed

Author: adriengivry

Resources/Engine/Shaders/Common/Utils.ovfxh

@@ -12,6 +12,53 @@ vec2 TileAndOffsetTexCoords(vec2 texCoords, vec2 tiling, vec2 offset)
     return vec2(mod(texCoords.x * tiling.x, 1), mod(texCoords.y * tiling.y, 1)) + offset;
 }
 
+// Expects a height map with values in the range [0, 1].
+// 1.0 means the height is at the maximum depth, 0.0 means the height is at the minimum depth.
+vec2 ApplyParallaxOcclusionMapping(vec2 texCoords, sampler2D heightMap, vec3 tangentViewPos, vec3 tangentFragPos, float heightScale)
+{
+    const vec3 viewDir = normalize(tangentViewPos - tangentFragPos);
+
+    // number of depth layers
+    const float minLayers = 8;
+    const float maxLayers = 64;
+    const float numLayers = mix(maxLayers, minLayers, abs(dot(vec3(0.0, 0.0, 1.0), viewDir)));  
+
+    // calculate the size of each layer
+    const float layerDepth = 1.0 / numLayers;
+    // the amount to shift the texture coordinates per layer (from vector P)
+    const vec2 P = viewDir.xy / viewDir.z * heightScale; 
+    const vec2 deltaTexCoords = P / numLayers;
+  
+    // get initial values
+    vec2 currentTexCoords = texCoords;
+    float currentDepthMapValue = 1.0 - texture(heightMap, currentTexCoords).r;
+    float currentLayerDepth = 0.0;
+      
+    while(currentLayerDepth < currentDepthMapValue)
+    {
+        // shift texture coordinates along direction of P
+        currentTexCoords -= deltaTexCoords;
+        // get depthmap value at current texture coordinates
+        currentDepthMapValue = 1.0 - texture(heightMap, currentTexCoords).r;
+        // get depth of next layer
+        currentLayerDepth += layerDepth;
+    }
+    
+    // get texture coordinates before collision (reverse operations)
+    const vec2 prevTexCoords = currentTexCoords + deltaTexCoords;
+
+    // get depth after and before collision for linear interpolation
+    const float afterDepth  = currentDepthMapValue - currentLayerDepth;
+    const float beforeDepth = 1.0 - texture(heightMap, prevTexCoords).r - currentLayerDepth + layerDepth;
+ 
+    // interpolation of texture coordinates
+    const float weight = afterDepth / (afterDepth - beforeDepth);
+    const vec2 finalTexCoords = prevTexCoords * weight + currentTexCoords * (1.0 - weight);
+
+    return finalTexCoords;
+}
+
+// [Deprecated] Kept for backward compatibility. Prefer using `ApplyParallaxOcclusionMapping()` instead.
 vec2 ApplyParallaxMapping(vec2 texCoords, sampler2D heightMap, vec3 tangentViewPos, vec3 tangentFragPos, float heightScale)
 {
     if (heightScale > 0)
@@ -24,6 +71,7 @@ vec2 ApplyParallaxMapping(vec2 texCoords, sampler2D heightMap, vec3 tangentViewP
     return texCoords;
 }
 
+// [Deprecated] Kept for backward compatibility.
 bool IsMasked(sampler2D maskMap, vec2 texCoords)
 {
     return texture(maskMap, texCoords).r == 0.0;
@@ -38,17 +86,23 @@ mat3 ConstructTBN(mat4 model, vec3 normal, vec3 tangent, vec3 bitangent)
     );
 }
 
+
+vec3 ComputeNormal(vec2 texCoords, vec3 normal, sampler2D normalMap, mat3 TBN)
+{
+    normal = texture(normalMap, texCoords).rgb;
+    normal = normalize(normal * 2.0 - 1.0);
+    normal = normalize(TBN * normal);
+    return normal;
+}
+
+// [Deprecated] Kept for backward compatibility. Prefer using `ComputeNormal()` without the `enableNormalMapping` parameter,
+// and handle branching using preprocessor directives instead.
 vec3 ComputeNormal(bool enableNormalMapping, vec2 texCoords, vec3 normal, sampler2D normalMap, mat3 TBN)
 {
     if (enableNormalMapping)
     {
-        normal = texture(normalMap, texCoords).rgb;
-        normal = normalize(normal * 2.0 - 1.0);   
-        normal = normalize(TBN * normal);
-        return normal;
-    }
-    else
-    {
-        return normalize(normal);
+        return ComputeNormal(texCoords, normal, normalMap, TBN);
     }
+
+    return normalize(normal);
 }

Resources/Engine/Shaders/Lambert.ovfx

@@ -53,20 +53,29 @@ uniform sampler2D u_DiffuseMap;
 uniform vec2 u_TextureTiling = vec2(1.0, 1.0);
 uniform vec2 u_TextureOffset = vec2(0.0, 0.0);
 
+#if defined(SHADOW_PASS)
+uniform float u_ShadowClippingThreshold = 0.5;
+#endif
+
 out vec4 FRAGMENT_COLOR;
 
 void main()
 {
+    const vec2 texCoords = TileAndOffsetTexCoords(fs_in.TexCoords, u_TextureTiling, u_TextureOffset);
+    const vec4 diffuse = texture(u_DiffuseMap, texCoords) * u_Diffuse;
+
 #if defined(SHADOW_PASS)
-    // Empty fragment shader for shadow pass
+    if (diffuse.a < u_ShadowClippingThreshold)
+    {
+        discard;
+    }
 #else
-    vec2 texCoords = TileAndOffsetTexCoords(fs_in.TexCoords, u_TextureTiling, u_TextureOffset);
 
     const vec3 kLightPosition = vec3(-9000.0, 10000.0, 11000.0);
     const vec3 kLightDiffuse = vec3(1.0);
     const vec3 kLightAmbient = vec3(0.3);
-    const vec3 lambert = ComputeLambertLighting(fs_in.FragPos, fs_in.Normal, kLightPosition, kLightDiffuse, kLightAmbient);
+    const vec3 lambert = diffuse.rgb * ComputeLambertLighting(fs_in.FragPos, fs_in.Normal, kLightPosition, kLightDiffuse, kLightAmbient);
 
-    FRAGMENT_COLOR = texture(u_DiffuseMap, texCoords) * u_Diffuse * vec4(lambert, 1.0);
+    FRAGMENT_COLOR = vec4(lambert, diffuse.a);
 #endif
 }

Resources/Engine/Shaders/Lighting/BlinnPhong.ovfxh

@@ -81,10 +81,11 @@ vec3 ComputeAmbientSphereLight(mat4 light, vec3 fragPos, vec4 diffuseTexel)
     return IsPointInSphere(fragPos, lightPosition, radius) ? diffuseTexel.rgb * lightColor * intensity : vec3(0.0);
 }
 
-vec4 ComputeBlinnPhongLighting(vec2 texCoords, vec3 normal, vec3 viewPos, vec3 fragPos, vec4 diffuse, vec3 specular, sampler2D diffuseMap, sampler2D specularMap, float shininess, sampler2D shadowMap, mat4 lightSpaceMatrix)
+// This version doesn't sample the diffuse texture, and expects the diffuse color to be passed in directly.
+// This is because other parts of the shader may have already sampled the diffuse texture, and we want to avoid double sampling.
+vec4 ComputeBlinnPhongLightingNoDiffuseSampling(vec2 texCoords, vec3 normal, vec3 viewPos, vec3 fragPos, vec4 diffuse, vec3 specular, sampler2D specularMap, float shininess, sampler2D shadowMap, mat4 lightSpaceMatrix)
 {
     vec3 viewDir = normalize(viewPos - fragPos);
-    vec4 diffuseTexel = texture(diffuseMap,  texCoords) * diffuse;
     vec4 specularTexel = texture(specularMap, texCoords) * vec4(specular, 1.0);
 
     vec3 lightAccumulation = vec3(0.0);
@@ -96,13 +97,31 @@ vec4 ComputeBlinnPhongLighting(vec2 texCoords, vec3 normal, vec3 viewPos, vec3 f
 
         switch(lightType)
         {
-            case 0: lightAccumulation += ComputePointLight(light, fragPos, diffuseTexel, specularTexel, normal, viewDir, shininess); break;
-            case 1: lightAccumulation += ComputeDirectionalLight(light, fragPos, diffuseTexel, specularTexel, normal, viewDir, shininess, shadowMap, lightSpaceMatrix); break;
-            case 2: lightAccumulation += ComputeSpotLight(light, fragPos, diffuseTexel, specularTexel, normal, viewDir, shininess); break;
-            case 3: lightAccumulation += ComputeAmbientBoxLight(light, fragPos, diffuseTexel); break;
-            case 4: lightAccumulation += ComputeAmbientSphereLight(light, fragPos, diffuseTexel); break;
+            case 0: lightAccumulation += ComputePointLight(light, fragPos, diffuse, specularTexel, normal, viewDir, shininess); break;
+            case 1: lightAccumulation += ComputeDirectionalLight(light, fragPos, diffuse, specularTexel, normal, viewDir, shininess, shadowMap, lightSpaceMatrix); break;
+            case 2: lightAccumulation += ComputeSpotLight(light, fragPos, diffuse, specularTexel, normal, viewDir, shininess); break;
+            case 3: lightAccumulation += ComputeAmbientBoxLight(light, fragPos, diffuse); break;
+            case 4: lightAccumulation += ComputeAmbientSphereLight(light, fragPos, diffuse); break;
         }
     }
 
-    return vec4(lightAccumulation, diffuseTexel.a);
+    return vec4(lightAccumulation, diffuse.a);
 }
+
+vec4 ComputeBlinnPhongLighting(vec2 texCoords, vec3 normal, vec3 viewPos, vec3 fragPos, vec4 diffuse, vec3 specular, sampler2D diffuseMap, sampler2D specularMap, float shininess, sampler2D shadowMap, mat4 lightSpaceMatrix)
+{
+    vec4 diffuseTexel = texture(diffuseMap, texCoords) * diffuse;
+
+    return ComputeBlinnPhongLightingNoDiffuseSampling(
+        texCoords,
+        normal,
+        viewPos,
+        fragPos,
+        diffuseTexel,
+        specular,
+        specularMap,
+        shininess,
+        shadowMap,
+        lightSpaceMatrix
+    );
+}

Resources/Engine/Shaders/Lighting/PBR.ovfxh

@@ -63,10 +63,11 @@ vec3 ComputeAmbientSphereLight(mat4 light, vec3 fragPos)
     return IsPointInSphere(fragPos, lightPosition, radius) ? lightColor * intensity : vec3(0.0);
 }
 
-vec4 ComputePBRLighting(vec2 texCoords, vec3 normal, vec3 viewPos, vec3 fragPos, vec4 inAlbedo, float inMetallic, float inRoughness, sampler2D albedoMap, sampler2D metallicMap, sampler2D roughnessMap, sampler2D aoMap, sampler2D shadowMap, mat4 lightSpaceMatrix)
+// This version doesn't sample the albedo texture, and expects the albedo color to be passed in directly.
+// This is because other parts of the shader may have already sampled the albedo texture, and we want to avoid double sampling.
+vec4 ComputePBRLightingNoAlbedoSampling(vec2 texCoords, vec3 normal, vec3 viewPos, vec3 fragPos, vec4 inAlbedo, float inMetallic, float inRoughness, sampler2D metallicMap, sampler2D roughnessMap, sampler2D aoMap, sampler2D shadowMap, mat4 lightSpaceMatrix)
 {
-    vec4 albedoRGBA = texture(albedoMap, texCoords) * inAlbedo;
-    vec3 albedo = pow(albedoRGBA.rgb, vec3(2.2));
+    vec3 albedo = pow(inAlbedo.rgb, vec3(2.2));
     float metallic = texture(metallicMap, texCoords).r * inMetallic;
     float roughness = texture(roughnessMap, texCoords).r * inRoughness;
     float ao = texture(aoMap, texCoords).r;
@@ -162,5 +163,24 @@ vec4 ComputePBRLighting(vec2 texCoords, vec3 normal, vec3 viewPos, vec3 fragPos,
     vec3 ambient = ambientSum * albedo * ao;
     vec3 color = ambient + Lo;
 
-    return vec4(color, albedoRGBA.a);
+    return vec4(color, inAlbedo.a);
+}
+
+vec4 ComputePBRLighting(vec2 texCoords, vec3 normal, vec3 viewPos, vec3 fragPos, vec4 inAlbedo, float inMetallic, float inRoughness, sampler2D albedoMap, sampler2D metallicMap, sampler2D roughnessMap, sampler2D aoMap, sampler2D shadowMap, mat4 lightSpaceMatrix)
+{
+    vec4 albedoRGBA = texture(albedoMap, texCoords) * inAlbedo;
+    return ComputePBRLightingNoAlbedoSampling(
+        texCoords,
+        normal,
+        viewPos,
+        fragPos,
+        albedoRGBA,
+        inMetallic,
+        inRoughness,
+        metallicMap,
+        roughnessMap,
+        aoMap,
+        shadowMap,
+        lightSpaceMatrix
+    );
 }

Resources/Engine/Shaders/Standard.ovfx

@@ -1,4 +1,7 @@
 #feature SHADOW_PASS
+#feature PARALLAX_MAPPING
+#feature ALPHA_CLIPPING
+#feature NORMAL_MAPPING
 
 #shader vertex
 #version 450 core
@@ -18,8 +21,10 @@ out VS_OUT
     vec2 TexCoords;
     vec3 Normal;
     mat3 TBN;
+#if defined(PARALLAX_MAPPING)
     flat vec3 TangentViewPos;
     vec3 TangentFragPos;
+#endif
 } vs_out;
 
 #if defined(SHADOW_PASS)
@@ -32,8 +37,11 @@ void main()
     vs_out.TexCoords = geo_TexCoords;
     vs_out.Normal = normalize(mat3(transpose(inverse(ubo_Model))) * geo_Normal);
     vs_out.TBN = ConstructTBN(ubo_Model, geo_Normal, geo_Tangent, geo_Bitangent);
+
+#if defined(PARALLAX_MAPPING)
     vs_out.TangentViewPos = transpose(vs_out.TBN) * ubo_ViewPos;
     vs_out.TangentFragPos = transpose(vs_out.TBN) * vs_out.FragPos;
+#endif
 
 #if defined(SHADOW_PASS)
     gl_Position = _LightSpaceMatrix * vec4(vs_out.FragPos, 1.0);
@@ -54,22 +62,38 @@ in VS_OUT
     vec2 TexCoords;
     vec3 Normal;
     mat3 TBN;
+#if defined(PARALLAX_MAPPING)
     flat vec3 TangentViewPos;
     vec3 TangentFragPos;
+#endif
 } fs_in;
 
-uniform vec2 u_TextureTiling = vec2(1.0, 1.0);
-uniform vec2 u_TextureOffset = vec2(0.0, 0.0);
+uniform sampler2D u_DiffuseMap;
+uniform sampler2D u_SpecularMap;
+uniform sampler2D u_MaskMap;
 uniform vec4 u_Diffuse = vec4(1.0, 1.0, 1.0, 1.0);
 uniform vec3 u_Specular = vec3(1.0, 1.0, 1.0);
+uniform vec2 u_TextureTiling = vec2(1.0, 1.0);
+uniform vec2 u_TextureOffset = vec2(0.0, 0.0);
 uniform float u_Shininess = 100.0;
-uniform float u_HeightScale = 0.0;
-uniform bool u_EnableNormalMapping = false;
-uniform sampler2D u_DiffuseMap;
-uniform sampler2D u_SpecularMap;
-uniform sampler2D u_NormalMap;
+
+#if defined(PARALLAX_MAPPING)
 uniform sampler2D u_HeightMap;
-uniform sampler2D u_MaskMap;
+uniform bool u_ParallaxClipEdges = false;
+uniform float u_HeightScale = 0.05;
+#endif
+
+#if defined(NORMAL_MAPPING)
+uniform sampler2D u_NormalMap;
+#endif
+
+#if defined(ALPHA_CLIPPING)
+uniform float u_AlphaClippingThreshold = 0.1;
+#endif
+
+#if defined(SHADOW_PASS)
+uniform float u_ShadowClippingThreshold = 0.5;
+#endif
 
 uniform sampler2D _ShadowMap;
 uniform mat4 _LightSpaceMatrix;
@@ -78,23 +102,48 @@ out vec4 FRAGMENT_COLOR;
 
 void main()
 {
+    vec2 texCoords = TileAndOffsetTexCoords(fs_in.TexCoords, u_TextureTiling, u_TextureOffset);
+
+#if defined(PARALLAX_MAPPING)
+    texCoords = ApplyParallaxOcclusionMapping(texCoords, u_HeightMap, fs_in.TangentViewPos, fs_in.TangentFragPos, u_HeightScale);
+    if (u_ParallaxClipEdges && (texCoords.x < 0.0 || texCoords.x > 1.0 || texCoords.y < 0.0 || texCoords.y > 1.0))
+    {
+        discard;
+    }
+#endif
+
+    vec4 diffuse = texture(u_DiffuseMap, texCoords) * u_Diffuse;
+    diffuse.a *= texture(u_MaskMap, texCoords).r;
+
 #if defined(SHADOW_PASS)
-    // Empty fragment shader for shadow pass
+    if (diffuse.a < u_ShadowClippingThreshold)
+    {
+        discard;
+    }
 #else
-    vec2 texCoords = TileAndOffsetTexCoords(fs_in.TexCoords, u_TextureTiling, u_TextureOffset);
-    texCoords = ApplyParallaxMapping(texCoords, u_HeightMap, fs_in.TangentViewPos, fs_in.TangentFragPos, u_HeightScale);
 
-    if (!IsMasked(u_MaskMap, texCoords))
+#if defined(ALPHA_CLIPPING)
+    if (diffuse.a < u_AlphaClippingThreshold)
+    {
+        discard;
+    }
+#endif
+
+    if (diffuse.a > 0.0)
     {
-        vec3 normal = ComputeNormal(u_EnableNormalMapping, texCoords, fs_in.Normal, u_NormalMap, fs_in.TBN);
-        FRAGMENT_COLOR = ComputeBlinnPhongLighting(
+#if defined(NORMAL_MAPPING)
+        const vec3 normal = ComputeNormal(texCoords, fs_in.Normal, u_NormalMap, fs_in.TBN);
+#else
+        const vec3 normal = normalize(fs_in.Normal);
+#endif
+
+        FRAGMENT_COLOR = ComputeBlinnPhongLightingNoDiffuseSampling(
             texCoords,
             normal,
             ubo_ViewPos,
             fs_in.FragPos,
-            u_Diffuse,
+            diffuse,
             u_Specular,
-            u_DiffuseMap,
             u_SpecularMap,
             u_Shininess,
             _ShadowMap,