feat: volumetric shadows

features/Hair Specular/Shaders/Hair/Hair.hlsli

@@ -194,7 +194,7 @@ namespace Hair
 
 	void GetHairDirectLightMarschner(out float3 dirDiffuse, out float3 dirSpecular, out float3 dirTransmission, float3 T, float3 L, float3 V, float3 N, float3 VN, float3 lightColor, float shininess, float selfShadow, float2 uv, float3 baseColor)
 	{
-		lightColor *= Color::PBRLightingCompensation * selfShadow;
+		lightColor *= Color::PBRLightingCompensation;
 		dirDiffuse = 0;
 		dirSpecular = 0;
 		dirTransmission = 0;
@@ -205,7 +205,7 @@ namespace Hair
 			T = ShiftTangent(T, N, shift);
 		}
 
-		float backlit = SharedData::hairSpecularSettings.Transmission;
+		float backlit = SharedData::hairSpecularSettings.Transmission * selfShadow;
 
 		dirTransmission += D_Marschner(L, V, T, roughness, baseColor, 0, backlit) * lightColor * SharedData::hairSpecularSettings.SpecularMult;
 		dirTransmission += GetHairDiffuseAttenuationKajiyaKay(T, V, L, selfShadow, baseColor) * lightColor * SharedData::hairSpecularSettings.DiffuseMult;
@@ -219,10 +219,13 @@ namespace Hair
 		const float3 VN = normalize(tbnTr[2]);
 		const float3 L = normalize(context.lightDir);
 
+		float3 lightColor = context.lightColor * context.detailedShadow;
+		float selfShadow = context.hairShadow * context.softShadow;
+
 		if (SharedData::hairSpecularSettings.HairMode == 0) {
-			GetHairDirectLightScheuermann(lightingOutput.diffuse, lightingOutput.specular, lightingOutput.transmission, T, L, V, N, VN, context.lightColor, material.Shininess, context.hairShadow, uv, material.BaseColor);
+			GetHairDirectLightScheuermann(lightingOutput.diffuse, lightingOutput.specular, lightingOutput.transmission, T, L, V, N, VN, lightColor, material.Shininess, selfShadow, uv, material.BaseColor);
 		} else {
-			GetHairDirectLightMarschner(lightingOutput.diffuse, lightingOutput.specular, lightingOutput.transmission, T, L, V, N, VN, context.lightColor, material.Shininess, context.hairShadow, uv, material.BaseColor);
+			GetHairDirectLightMarschner(lightingOutput.diffuse, lightingOutput.specular, lightingOutput.transmission, T, L, V, N, VN, lightColor, material.Shininess, selfShadow, uv, material.BaseColor);
 		}
 	}
 

features/Terrain Shadows/Shaders/Features/TerrainShadows.ini

@@ -1,2 +1,2 @@
 [Info]
-Version = 1-0-1
+Version = 1-0-2

features/Terrain Shadows/Shaders/TerrainShadows/ShadowUpdate.cs.hlsl

@@ -81,7 +81,7 @@ groupshared float2 g_shadowHeight[NTHREADS];
 	float2 threadUV = rawThreadUV - floor(rawThreadUV);  // wraparound
 	float2 threadPxCoord = threadUV * dims;
 
-float2 pastHeights = 0.0f.xx;
+	float2 pastHeights = 0.0;
 	if (isValid) {
 		pastHeights = RWTexShadowHeights[uint2(threadPxCoord)];
 

features/Terrain Shadows/Shaders/TerrainShadows/TerrainShadows.hlsli

@@ -9,7 +9,7 @@ namespace TerrainShadows
 
 	float GetTerrainZ(float norm_z)
 	{
-		return lerp(SharedData::terraOccSettings.ZRange.x, SharedData::terraOccSettings.ZRange.y, norm_z) - 1024;
+		return lerp(SharedData::terraOccSettings.ZRange.x, SharedData::terraOccSettings.ZRange.y, norm_z) - 256;
 	}
 
 	float2 GetTerrainZ(float2 norm_z)

features/Volumetric Shadows/Shaders/Features/VolumetricShadows.ini

@@ -0,0 +1,2 @@
+[Info]
+Version = 2-0-0

features/Volumetric Shadows/Shaders/VolumetricShadows/BlurShadowCS.hlsl

@@ -0,0 +1,104 @@
+// 11x11 separable Gaussian blur for VSM shadow map
+// BLUR_HORIZONTAL - horizontal pass
+// BLUR_VERTICAL - vertical pass
+
+Texture2D<float2> InputTexture : register(t0);
+RWTexture2D<float2> OutputTexture : register(u0);
+
+// Gaussian weights for 11-tap kernel (sigma ~= 2.5)
+static const float weights[6] = {
+	0.198596,  // center
+	0.175713,  // +/- 1
+	0.121703,  // +/- 2
+	0.065984,  // +/- 3
+	0.028002,  // +/- 4
+	0.009302   // +/- 5
+};
+
+#define KERNEL_RADIUS 5
+#define GROUP_SIZE 128
+
+// Shared memory for efficient loading
+// We need GROUP_SIZE + 2 * KERNEL_RADIUS elements
+groupshared float2 g_cache[GROUP_SIZE + 2 * KERNEL_RADIUS];
+
+#if defined(BLUR_HORIZONTAL)
+[numthreads(GROUP_SIZE, 1, 1)]
+void main(uint3 groupID : SV_GroupID, uint3 groupThreadID : SV_GroupThreadID, uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+	uint width, height;
+	InputTexture.GetDimensions(width, height);
+
+	int2 baseCoord = int2(groupID.x * GROUP_SIZE - KERNEL_RADIUS, groupID.y);
+	int localIdx = groupThreadID.x;
+
+	// Load main data
+	int2 coord = baseCoord + int2(localIdx, 0);
+	coord.x = clamp(coord.x, 0, (int)width - 1);
+	g_cache[localIdx] = InputTexture[coord];
+
+	// Load extra data for kernel overlap
+	if (localIdx < 2 * KERNEL_RADIUS) {
+		coord = baseCoord + int2(GROUP_SIZE + localIdx, 0);
+		coord.x = clamp(coord.x, 0, (int)width - 1);
+		g_cache[GROUP_SIZE + localIdx] = InputTexture[coord];
+	}
+
+	GroupMemoryBarrierWithGroupSync();
+
+	// Only process valid pixels
+	if (dispatchThreadID.x >= width || dispatchThreadID.y >= height)
+		return;
+
+	// Apply horizontal blur
+	float2 result = g_cache[localIdx + KERNEL_RADIUS] * weights[0];
+
+	[unroll]
+	for (int i = 1; i <= KERNEL_RADIUS; i++) {
+		result += g_cache[localIdx + KERNEL_RADIUS - i] * weights[i];
+		result += g_cache[localIdx + KERNEL_RADIUS + i] * weights[i];
+	}
+
+	OutputTexture[dispatchThreadID.xy] = result;
+}
+
+#elif defined(BLUR_VERTICAL)
+[numthreads(1, GROUP_SIZE, 1)]
+void main(uint3 groupID : SV_GroupID, uint3 groupThreadID : SV_GroupThreadID, uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+	uint width, height;
+	InputTexture.GetDimensions(width, height);
+
+	int2 baseCoord = int2(groupID.x, groupID.y * GROUP_SIZE - KERNEL_RADIUS);
+	int localIdx = groupThreadID.y;
+
+	// Load main data
+	int2 coord = baseCoord + int2(0, localIdx);
+	coord.y = clamp(coord.y, 0, (int)height - 1);
+	g_cache[localIdx] = InputTexture[coord];
+
+	// Load extra data for kernel overlap
+	if (localIdx < 2 * KERNEL_RADIUS) {
+		coord = baseCoord + int2(0, GROUP_SIZE + localIdx);
+		coord.y = clamp(coord.y, 0, (int)height - 1);
+		g_cache[GROUP_SIZE + localIdx] = InputTexture[coord];
+	}
+
+	GroupMemoryBarrierWithGroupSync();
+
+	// Only process valid pixels
+	if (dispatchThreadID.x >= width || dispatchThreadID.y >= height)
+		return;
+
+	// Apply vertical blur
+	float2 result = g_cache[localIdx + KERNEL_RADIUS] * weights[0];
+
+	[unroll]
+	for (int i = 1; i <= KERNEL_RADIUS; i++) {
+		result += g_cache[localIdx + KERNEL_RADIUS - i] * weights[i];
+		result += g_cache[localIdx + KERNEL_RADIUS + i] * weights[i];
+	}
+
+	OutputTexture[dispatchThreadID.xy] = result;
+}
+#endif

package/Shaders/CopyShadowDataCS.hlsl → features/Volumetric Shadows/Shaders/VolumetricShadows/CopyShadowDataCS.hlsl

@@ -126,4 +126,4 @@ RWStructuredBuffer<PerGeometry> ShadowData : register(u0);
 	perGeometry.FocusShadowFadeParam = FocusShadowFadeParam;
 
 	ShadowData[0] = perGeometry;
-}
+}

features/Volumetric Shadows/Shaders/VolumetricShadows/DownsampleShadowCS.hlsl

@@ -0,0 +1,100 @@
+Texture2DArray<float> InputTexture : register(t0);
+Texture2DArray<float> ESRAMShadow : register(t1);
+RWTexture2D<float2> OutputTexture : register(u0);
+SamplerState LinearSampler : register(s0);
+
+float2 GetVSMMoments(in float depth)
+{
+    return float2(depth, depth * depth);
+}
+
+float2 ReduceMoments(float2 a, float2 b, float2 c, float2 d)
+{
+	return (a + b + c + d) * 0.25;
+}
+
+groupshared float2 g_scratchDepths[8][8];
+
+#if defined(DOWNSAMPLE_SHADOW_MIP0)
+static const uint CASCADE = 1;
+#elif defined(DOWNSAMPLE_SHADOW_MIP1)
+static const uint CASCADE = 0;
+#endif
+
+[numthreads(8, 8, 1)]
+void main(uint3 dispatchThreadID : SV_DispatchThreadID, uint3 groupThreadID : SV_GroupThreadID) {
+	uint2 pixCoord = dispatchThreadID.xy * 2;
+
+	uint inputW, inputH, inputSlices;
+	InputTexture.GetDimensions(inputW, inputH, inputSlices);
+	float2 uv = (pixCoord + 0.5) / float2(inputW, inputH);
+
+	uint outputW, outputH;
+	OutputTexture.GetDimensions(outputW, outputH);
+
+	// Determine reduction levels from input/output ratio
+	// Gather handles 2x, each group reduction handles another 2x
+	uint totalReduction = inputW / outputW;
+	uint groupReductions = 0;
+	if (totalReduction >= 4) groupReductions = 1;
+	if (totalReduction >= 8) groupReductions = 2;
+	if (totalReduction >= 16) groupReductions = 3;
+
+	// Gather from shadow cascades and mix with ESRAM shadow
+	float4 depths = InputTexture.GatherRed(LinearSampler, float3(uv, CASCADE));
+	float4 esramDepths = ESRAMShadow.GatherRed(LinearSampler, float3(uv, CASCADE));
+	depths = min(depths, esramDepths);
+
+	float2 vsmDepth = 0;
+	for(uint i = 0; i < 4; i++)
+		vsmDepth += GetVSMMoments(depths[i]);
+	vsmDepth *= 0.25;
+
+	g_scratchDepths[groupThreadID.x][groupThreadID.y] = vsmDepth;
+
+	GroupMemoryBarrierWithGroupSync();
+
+	// First reduction: 2x2
+	if (groupReductions >= 1) {
+		if (all((groupThreadID.xy % 2) == 0)) {
+			uint2 tid = groupThreadID.xy;
+			g_scratchDepths[tid.x][tid.y] = ReduceMoments(
+				g_scratchDepths[tid.x + 0][tid.y + 0],
+				g_scratchDepths[tid.x + 1][tid.y + 0],
+				g_scratchDepths[tid.x + 0][tid.y + 1],
+				g_scratchDepths[tid.x + 1][tid.y + 1]);
+		}
+		GroupMemoryBarrierWithGroupSync();
+	}
+
+	// Second reduction: 4x4
+	if (groupReductions >= 2) {
+		if (all((groupThreadID.xy % 4) == 0)) {
+			uint2 tid = groupThreadID.xy;
+			g_scratchDepths[tid.x][tid.y] = ReduceMoments(
+				g_scratchDepths[tid.x + 0][tid.y + 0],
+				g_scratchDepths[tid.x + 2][tid.y + 0],
+				g_scratchDepths[tid.x + 0][tid.y + 2],
+				g_scratchDepths[tid.x + 2][tid.y + 2]);
+		}
+		GroupMemoryBarrierWithGroupSync();
+	}
+
+	// Third reduction: 8x8
+	if (groupReductions >= 3) {
+		if (all(groupThreadID.xy == 0)) {
+			g_scratchDepths[0][0] = ReduceMoments(
+				g_scratchDepths[0][0],
+				g_scratchDepths[4][0],
+				g_scratchDepths[0][4],
+				g_scratchDepths[4][4]);
+		}
+		GroupMemoryBarrierWithGroupSync();
+	}
+
+	// Write output - only threads aligned to the output grid
+	uint outputDiv = max(totalReduction / 2, 1);
+	if (all((groupThreadID.xy % outputDiv) == 0)) {
+		OutputTexture[dispatchThreadID.xy / outputDiv] = g_scratchDepths[groupThreadID.x][groupThreadID.y];
+	}
+}