add shadowing to parallax geometry

Author: ook3D

CodeWalker.Shaders/BasicPS.hlsl

@@ -5,14 +5,27 @@ float4 main(VS_OUTPUT input) : SV_TARGET
 {
     // Calculate parallax offset if height mapping is enabled
     float2 parallaxTexOffset = float2(0, 0);
+    float parallaxSelfShadow = 1.0;
     if (EnableHeightMap && RenderMode == 0)
     {
         float3 viewDir = -normalize(input.CamRelPos); // Negate to get direction FROM surface TO camera
+        float3 norm0 = normalize(input.Normal);
+        float3 tang0 = normalize(input.Tangent.xyz);
+        float3 bitang0 = normalize(input.Bitangent.xyz);
         parallaxTexOffset = ParallaxOffset(
             Heightmap, TextureSS, input.Texcoord0,
-            viewDir, normalize(input.Normal),
-            normalize(input.Tangent.xyz), normalize(input.Bitangent.xyz),
+            viewDir, norm0, tang0, bitang0,
             heightScale, heightBias);
+
+        // Parallax self-shadow, transform light dir to tangent space and trace
+        float3 tanLightDir;
+        tanLightDir.x = dot(tang0, GlobalLights.LightDir.xyz);
+        tanLightDir.y = dot(bitang0, GlobalLights.LightDir.xyz);
+        tanLightDir.z = dot(norm0, GlobalLights.LightDir.xyz);
+        float shadowAmount = TraceSelfShadow(Heightmap, TextureSS,
+            input.Texcoord0 + parallaxTexOffset,
+            tanLightDir, 1.0, heightScale);
+        parallaxSelfShadow = 1.0 - shadowAmount * PARALLAX_SELF_SHADOW_AMOUNT;
     }
 
     // Apply parallax offset to base texture coordinates
@@ -176,7 +189,7 @@ float4 main(VS_OUTPUT input) : SV_TARGET
 
     float4 fc = c;
 
-    c.rgb = FullLighting(c.rgb, spec, norm, input.Colour0, GlobalLights, EnableShadows, input.Shadows.x, input.LightShadow);
+    c.rgb = FullLighting(c.rgb, spec, norm, input.Colour0, GlobalLights, EnableShadows, input.Shadows.x, input.LightShadow, parallaxSelfShadow);
 
 
     if (IsEmissive==1)

CodeWalker.Shaders/Common.hlsli

@@ -215,6 +215,30 @@ float TraceHeight(Texture2D<float4> heightMapSampler, SamplerState samplerState,
     return clamp(finalHeight, 0.0, 1.0f);
 }
 
+// Parallax self-shadow: traces through heightmap in light direction to find occlusion
+// Returns shadow factor (0 = fully lit, 1 = fully in shadow)
+float TraceSelfShadow(Texture2D<float4> heightMapSampler, SamplerState samplerState, float2 texCoords, float3 tanLightDir, float edgeWeight, float hScale)
+{
+    float2 inXY = (tanLightDir.xy * hScale * edgeWeight) / max(tanLightDir.z, 0.01f);
+
+    // Sample base height at current (displaced) position
+    float sh0 = heightMapSampler.SampleLevel(samplerState, texCoords, 0).r;
+
+    // Trace 7 samples along light direction with increasing weight for closer occlusion
+    float shA = (heightMapSampler.SampleLevel(samplerState, texCoords + inXY * 0.88, 0).r - sh0 - 0.88) *  1;
+    float sh9 = (heightMapSampler.SampleLevel(samplerState, texCoords + inXY * 0.77, 0).r - sh0 - 0.77) *  2;
+    float sh8 = (heightMapSampler.SampleLevel(samplerState, texCoords + inXY * 0.66, 0).r - sh0 - 0.66) *  4;
+    float sh7 = (heightMapSampler.SampleLevel(samplerState, texCoords + inXY * 0.55, 0).r - sh0 - 0.55) *  6;
+    float sh6 = (heightMapSampler.SampleLevel(samplerState, texCoords + inXY * 0.44, 0).r - sh0 - 0.44) *  8;
+    float sh5 = (heightMapSampler.SampleLevel(samplerState, texCoords + inXY * 0.33, 0).r - sh0 - 0.33) * 10;
+    float sh4 = (heightMapSampler.SampleLevel(samplerState, texCoords + inXY * 0.22, 0).r - sh0 - 0.22) * 12;
+
+    float finalHeight = max(max(max(max(max(max(shA, sh9), sh8), sh7), sh6), sh5), sh4);
+    return saturate(finalHeight);
+}
+
+#define PARALLAX_SELF_SHADOW_AMOUNT 0.95f
+
 // Calculate parallax texture coordinate offset
 float2 ParallaxOffset(Texture2D<float4> heightMapSampler, SamplerState samplerState, float2 texCoords,
                        float3 viewDir, float3 normal, float3 tangent, float3 bitangent,

CodeWalker.Shaders/Shadowmap.hlsli

@@ -225,7 +225,7 @@ float ShadowAmount(float4 shadowcoord, float shadowdepth)//, inout float4 colour
 
 
 
-float3 FullLighting(float3 diff, float3 spec, float3 norm, float4 vc0, uniform ShaderGlobalLightParams globalLights, uint enableShadows, float shadowdepth, float4 shadowcoord)
+float3 FullLighting(float3 diff, float3 spec, float3 norm, float4 vc0, uniform ShaderGlobalLightParams globalLights, uint enableShadows, float shadowdepth, float4 shadowcoord, float selfShadow = 1.0)
 {
     float lf = saturate(dot(norm, globalLights.LightDir.xyz));
 
@@ -241,6 +241,9 @@ float3 FullLighting(float3 diff, float3 spec, float3 norm, float4 vc0, uniform S
         }
     }
 
+    // Apply parallax self-shadow to cascade shadow
+    shadowlit *= selfShadow;
+
     lf *= shadowlit;
 
     float3 speclit = spec*shadowlit;

CodeWalker.Shaders/TerrainPS.hlsl

@@ -169,6 +169,25 @@ float2 CalculateTerrainParallaxOffset(float4 layerBlends, float2 texCoord, float
     return heightBiasOffset + (maxParallaxOffset * (1.0f - saturate(refinedHeight)));
 }
 
+// Terrain-specific self-shadow using blended heightmaps
+float TraceTerrainSelfShadow(float4 layerBlends, float2 texCoords, float3 tanLightDir, float edgeWeight, float hScale)
+{
+    float2 inXY = (tanLightDir.xy * hScale * edgeWeight) / max(tanLightDir.z, 0.01f);
+
+    float sh0 = 1.0f - BlendTerrainHeight(layerBlends, texCoords);
+
+    float shA = (1.0f - BlendTerrainHeight(layerBlends, texCoords + inXY * 0.88) - sh0 - 0.88) *  1;
+    float sh9 = (1.0f - BlendTerrainHeight(layerBlends, texCoords + inXY * 0.77) - sh0 - 0.77) *  2;
+    float sh8 = (1.0f - BlendTerrainHeight(layerBlends, texCoords + inXY * 0.66) - sh0 - 0.66) *  4;
+    float sh7 = (1.0f - BlendTerrainHeight(layerBlends, texCoords + inXY * 0.55) - sh0 - 0.55) *  6;
+    float sh6 = (1.0f - BlendTerrainHeight(layerBlends, texCoords + inXY * 0.44) - sh0 - 0.44) *  8;
+    float sh5 = (1.0f - BlendTerrainHeight(layerBlends, texCoords + inXY * 0.33) - sh0 - 0.33) * 10;
+    float sh4 = (1.0f - BlendTerrainHeight(layerBlends, texCoords + inXY * 0.22) - sh0 - 0.22) * 12;
+
+    float finalHeight = max(max(max(max(max(max(shA, sh9), sh8), sh7), sh6), sh5), sh4);
+    return saturate(finalHeight);
+}
+
 float4 main(VS_OUTPUT input) : SV_TARGET
 {
     float4 vc0 = input.Colour0;
@@ -192,7 +211,8 @@ float4 main(VS_OUTPUT input) : SV_TARGET
     layerBlends.z = vc1.g * (1.0f - vc1.b);
     layerBlends.w = vc1.g * vc1.b;
 
-    // Calculate single parallax offset using blended heights (GTA V approach)
+    // Calculate single parallax offset using blended heights
+    float parallaxSelfShadow = 1.0;
     if (EnableHeightMap && RenderMode == 0)
     {
         float3 viewDir = -normalize(input.CamRelPos); // Negate to get direction FROM surface TO camera
@@ -209,6 +229,17 @@ float4 main(VS_OUTPUT input) : SV_TARGET
         sc2 += parallaxOffset;
         sc3 += parallaxOffset;
         sc4 += parallaxOffset;
+
+        // Parallax self-shadow, transform light dir to tangent space and trace blended heights
+        float3 tanLightDir;
+        tanLightDir.x = dot(tang, GlobalLights.LightDir.xyz);
+        tanLightDir.y = dot(bitang, GlobalLights.LightDir.xyz);
+        tanLightDir.z = dot(norm, GlobalLights.LightDir.xyz);
+        float2 blendedScaleBias = GetBlendedScaleBias(layerBlends);
+        float blendedHScale = blendedScaleBias.x * POM_HEIGHT_SCALE;
+        float edgeWeight = 1.0f - saturate(input.EdgeWeight.x);
+        float shadowAmount = TraceTerrainSelfShadow(layerBlends, sc0, tanLightDir, edgeWeight, blendedHScale);
+        parallaxSelfShadow = 1.0 - shadowAmount * PARALLAX_SELF_SHADOW_AMOUNT;
     }
 
     float4 bc0 = float4(0.5, 0.5, 0.5, 1);
@@ -392,7 +423,7 @@ float4 main(VS_OUTPUT input) : SV_TARGET
 
     float3 spec = 0;
 
-    tv.rgb = FullLighting(tv.rgb, spec, norm, vc0, GlobalLights, EnableShadows, input.Shadows.x, input.LightShadow);
+    tv.rgb = FullLighting(tv.rgb, spec, norm, vc0, GlobalLights, EnableShadows, input.Shadows.x, input.LightShadow, parallaxSelfShadow);
 
 
     return float4(tv.rgb, saturate(tv.a));