@forgeax/engine-shader 0.1.27 → 0.1.29

package/src/shadow_caster.wgsl

@@ -1,43 +1,32 @@
 #pragma variant_axis STORAGE_BUFFER_AVAILABLE
 #pragma variant_axis SKINNING_DISABLED
+#pragma variant_axis GPU_DRIVEN_SCENE_INDEX_AVAILABLE
+#pragma variant_axis GPU_DRIVEN_SCENE_INDEX_EXPLICIT
+#pragma variant_axis ALPHA_MASK
 #pragma material_slot surface
 #define_import_path forgeax::default-shadow-caster
-#import forgeax_material::slot::surface::{evaluate_surface}
+#import forgeax_material::slot::surface::{evaluate_surface, evaluate_standard_surface}
 #import forgeax_material::surface_v1::{SurfaceInput, SurfaceData}
 #import forgeax_material::parameters::{material}
 
-// @forgeax/engine-shader shadow_caster.wgsl
-// feat-20260520-directional-light-shadow-mapping M1c / w9 (D-9 / AC-09):
-// depth pass for directional shadow map. The fragment stage evaluates the
-// selected Standard Surface so opacity/alpha-clip stays identical to Forward
-// and Deferred (depth32float is still the only render target).
-//
-// feat-20260613-csm-cascaded-shadow-maps M5 / w28: per-cascade
-// lightViewProj selection. Each cascade pass writes a different
-// `shadowCasterCascade.index` (0..3) before encoder submit; the vertex
-// shader reads it to pick `view.lightViewProj_A..D`. The atlas tile UV
-// inset is already baked into each lightViewProj host-side
-// (render-system-extract.ts), so the per-cascade viewport on the depth
-// pass clips rasterization to the correct atlas tile while the matrix
-// itself maps NDC straight into atlas-space [0,1]^2.
-//
-// Reuses:
-//   @group(0) binding(0) view : View                 -- common.wgsl
-//   @group(0) binding(5) shadowCasterCascade         -- common.wgsl
-//   @group(2) binding(0) meshes : array<Mesh>        -- common.wgsl
-//   @group(3) binding(0) instances : array<InstanceData>  -- common.wgsl
-//
-// SKINNING_DISABLED=true consumes the ordinary 12F mesh layout; the explicit
-// false variant consumes JOINTS_0 / WEIGHTS_0 from the same 18F layout as pbr-skin and
-// projects the animated world-space palette result into the shadow view.
+#import forgeax_view::common::{View, Mesh, InstanceData, ShadowCasterCascade, view, shadowCasterCascade, meshes, instances, sampleMaterialTexture}
 
-#import forgeax_view::common::{View, Mesh, InstanceData, ShadowCasterCascade, view, shadowCasterCascade, meshes, instances}
+// The depth pass shares the Standard Surface contract with Forward/Deferred.
+// Alpha-mask and GPU scene-index variants add only producer-owned bindings;
+// ordinary casters keep the same four-slot pipeline layout.
 
 struct VsInput {
   @location(0) position : vec3<f32>,
   @location(1) normal : vec3<f32>,
   @location(2) uv : vec2<f32>,
   @location(3) tangent : vec4<f32>,
+  @location(6) uv1 : vec2<f32>,
+  @location(7) uv2 : vec2<f32>,
+  @location(8) uv3 : vec2<f32>,
+  @location(9) uv4 : vec2<f32>,
+  @location(10) uv5 : vec2<f32>,
+  @location(11) uv6 : vec2<f32>,
+  @location(12) uv7 : vec2<f32>,
 #if SKINNING_DISABLED == false
   @location(4) skinIndex : vec4<u32>,
   @location(5) skinWeight : vec4<f32>,
@@ -51,9 +40,22 @@ struct VsOut {
   @location(2) normalWS : vec3<f32>,
   @location(3) tangentWS : vec4<f32>,
   @location(4) surfaceUv : vec2<f32>,
-  @location(5) vertexColor : vec4<f32>,
+  @location(5) uv1 : vec2<f32>,
+  @location(6) uv2 : vec2<f32>,
+  @location(7) uv3 : vec2<f32>,
+  @location(8) uv4 : vec2<f32>,
+  @location(9) uv5 : vec2<f32>,
+  @location(10) uv6And7 : vec4<f32>,
+#if GPU_DRIVEN_SCENE_INDEX_AVAILABLE == true
+  @location(11) @interpolate(flat) materialIndex : u32,
+#endif
 };
 
+#if GPU_DRIVEN_SCENE_INDEX_AVAILABLE == true
+@group(1) @binding(46) var<storage, read> sceneMaterials : array<MaterialParameters>;
+@group(3) @binding(1) var<storage, read> visibleItems : array<vec2<u32>>;
+#endif
+
 #if SKINNING_DISABLED == false
 #if STORAGE_BUFFER_AVAILABLE == true
 @group(2) @binding(1) var<storage, read> palette : array<mat4x4<f32>>;
@@ -71,67 +73,102 @@ fn _cascadeLightViewProj(layer : u32) -> mat4x4<f32> {
   }
 }
 
-@vertex
-fn vs_main(in : VsInput, @builtin(instance_index) idx : u32) -> VsOut {
+fn shadowVertex(in : VsInput, idx : u32) -> VsOut {
+  var meshIndex = 0u;
+  var instanceIndex = idx;
+  var materialIndex = 0u;
+  var paletteBase = 0u;
+#if GPU_DRIVEN_SCENE_INDEX_AVAILABLE == true
+#if GPU_DRIVEN_SCENE_INDEX_EXPLICIT == false
+  let visible = visibleItems[idx];
+  meshIndex = visible.x;
+  instanceIndex = 0u;
+  paletteBase = visible.y;
+  materialIndex = visible.y;
+#endif
+#endif
 #if SKINNING_DISABLED == false
-  let skinMatrix = palette[in.skinIndex.x] * in.skinWeight.x +
-    palette[in.skinIndex.y] * in.skinWeight.y +
-    palette[in.skinIndex.z] * in.skinWeight.z +
-    palette[in.skinIndex.w] * in.skinWeight.w;
-  // Palette entries are jointWorld * inverseBind and therefore already
-  // produce world-space positions. Applying meshes[0].worldFromLocal again
-  // would double-transform a parented skinned entity.
+#if STORAGE_BUFFER_AVAILABLE == true
+  // GPU skin rows carry the material row in the Mesh temporal metadata lane.
+  materialIndex = bitcast<u32>(meshes[meshIndex].temporal.w);
+#endif
+  let skinMatrix = palette[paletteBase + in.skinIndex.x] * in.skinWeight.x +
+    palette[paletteBase + in.skinIndex.y] * in.skinWeight.y +
+    palette[paletteBase + in.skinIndex.z] * in.skinWeight.z +
+    palette[paletteBase + in.skinIndex.w] * in.skinWeight.w;
   let worldPos = skinMatrix * vec4<f32>(in.position, 1.0);
   let worldNormal = normalize((skinMatrix * vec4<f32>(in.normal, 0.0)).xyz);
   let worldTangent = normalize((skinMatrix * vec4<f32>(in.tangent.xyz, 0.0)).xyz);
 #else
-  let instanceLocal = instances[idx].localFromInstance;
-  let worldMatrix = meshes[0].worldFromLocal * instanceLocal;
+  let worldMatrix = meshes[meshIndex].worldFromLocal * instances[instanceIndex].localFromInstance;
   let worldPos = worldMatrix * vec4<f32>(in.position, 1.0);
   let worldNormal = normalize((worldMatrix * vec4<f32>(in.normal, 0.0)).xyz);
   let worldTangent = normalize((worldMatrix * vec4<f32>(in.tangent.xyz, 0.0)).xyz);
 #endif
-  // feat-20260625-spot-light-shadow-mapping M2 / w10 (D-1): spot shadow passes
-  // set `isSpot = 1u` and write their perspective matrix into
-  // `spotLightViewProj`; directional cascade passes keep `isSpot = 0u` and read
-  // `view.lightViewProj_A..D` via `index`. Routing on the discriminant keeps
-  // the spot matrix out of the directional View UBO (no same-frame contention).
+
+  var out : VsOut;
   if (shadowCasterCascade.isSpot == 1u) {
-    var out : VsOut;
     out.clip = shadowCasterCascade.spotLightViewProj * worldPos;
-    out.positionOS = in.position;
-    out.positionWS = worldPos.xyz;
-    out.normalWS = worldNormal;
-    out.tangentWS = vec4<f32>(worldTangent, in.tangent.w);
-    out.surfaceUv = in.uv;
-    out.vertexColor = vec4<f32>(1.0);
-    return out;
+  } else {
+    out.clip = _cascadeLightViewProj(shadowCasterCascade.index) * worldPos;
   }
-  let lvp = _cascadeLightViewProj(shadowCasterCascade.index);
-  var out : VsOut;
-  out.clip = lvp * worldPos;
   out.positionOS = in.position;
   out.positionWS = worldPos.xyz;
   out.normalWS = worldNormal;
   out.tangentWS = vec4<f32>(worldTangent, in.tangent.w);
   out.surfaceUv = in.uv;
-  out.vertexColor = vec4<f32>(1.0);
+  out.uv1 = in.uv1;
+  out.uv2 = in.uv2;
+  out.uv3 = in.uv3;
+  out.uv4 = in.uv4;
+  out.uv5 = in.uv5;
+  out.uv6And7 = vec4<f32>(in.uv6, in.uv7);
+#if GPU_DRIVEN_SCENE_INDEX_AVAILABLE == true
+  out.materialIndex = materialIndex;
+#endif
   return out;
 }
 
+@vertex
+fn vs_main(in : VsInput, @builtin(instance_index) idx : u32) -> VsOut {
+  return shadowVertex(in, idx);
+}
+
+// Scene-index shadow batches use a receipt-owned entry point so the indirect
+// lane cannot silently reinterpret the visible stream as instance indices.
+@vertex
+fn vs_scene_index(in : VsInput, @builtin(instance_index) idx : u32) -> VsOut {
+  return shadowVertex(in, idx);
+}
+
 fn evaluateShadowSurface(in : VsOut, frontFacing : bool) -> SurfaceData {
   let viewDirectionWS = normalize(view.cameraPos - in.positionWS);
-  return evaluate_surface(SurfaceInput(
+  let input = SurfaceInput(
     in.positionOS,
     in.positionWS,
     in.normalWS,
     in.tangentWS,
     viewDirectionWS,
     in.surfaceUv,
-    in.surfaceUv,
-    in.vertexColor,
+    in.uv1,
+    in.uv2,
+    in.uv3,
+    in.uv4,
+    in.uv5,
+    in.uv6And7.xy,
+    in.uv6And7.zw,
+    vec4<f32>(1.0),
     frontFacing,
-  ));
+  );
+#if GPU_DRIVEN_SCENE_INDEX_AVAILABLE == true
+#if ALPHA_MASK == true
+  return evaluate_standard_surface(input, sceneMaterials[in.materialIndex]);
+#else
+  return evaluate_surface(input);
+#endif
+#else
+  return evaluate_surface(input);
+#endif
 }
 
 fn alphaTestShadowSurface(surface : SurfaceData) {
@@ -140,13 +177,14 @@ fn alphaTestShadowSurface(surface : SurfaceData) {
   }
 }
 
-// The depth-only path evaluates the selected Surface so alpha-clip ownership
-// remains shared with Forward and Deferred without mutating vertex data.
+// The depth-only pass has no color target; alpha clipping still runs through
+// the selected Standard Surface before depth is committed.
 @fragment
 fn fs_shadow(in : VsOut, @builtin(front_facing) frontFacing : bool) {
   alphaTestShadowSurface(evaluateShadowSurface(in, frontFacing));
 }
 
+// Keep fs_main available for material consumers that explicitly request it.
 @fragment
 fn fs_main(in : VsOut, @builtin(front_facing) frontFacing : bool) {
   alphaTestShadowSurface(evaluateShadowSurface(in, frontFacing));

package/src/sprite-lit.wgsl

@@ -90,7 +90,7 @@ struct VsIn {
 // a valid source for NDC cluster lookup; keep the perspective divide here and
 // interpolate the result alongside worldPos.
 struct VsOut {
-  @builtin(position) clip     : vec4<f32>,
+  @builtin(position) @invariant clip     : vec4<f32>,
   @location(0)       uv_atlas : vec2<f32>,
   @location(1)       worldPos : vec3<f32>,
   @location(2)       ndc      : vec3<f32>,
@@ -199,7 +199,7 @@ fn spriteLitShadeAccum(
   let viewDir = normalize(view.cameraPos - worldPos);
   lit = lit + evaluateStandardClusterLights(
     ndc, viewZ, worldPos, vec3<f32>(0.0, 0.0, 1.0),
-    viewDir, albedo, 0.0, 1.0, vec3<f32>(0.04), true,
+    viewDir, albedo, 0.0, 1.0, vec3<f32>(0.04), true, true,
   );
 #endif
   return lit;
@@ -236,7 +236,7 @@ fn fs_main_hdr(in : VsOut) -> @location(0) vec4<f32> {
 }
 
 struct TemporalVsOut {
-  @builtin(position) clip : vec4<f32>,
+  @builtin(position) @invariant clip : vec4<f32>,
   @location(0) uvAtlas : vec2<f32>,
   @location(1) @interpolate(perspective) currentClip : vec4<f32>,
   @location(2) @interpolate(perspective) previousClip : vec4<f32>,
@@ -254,7 +254,7 @@ fn vs_temporal(in : VsIn, @builtin(instance_index) idx : u32, @builtin(vertex_in
 #endif
   var out : TemporalVsOut;
   out.currentClip = view.temporalCurrentViewProj * currentWorld;
-  out.clip = out.currentClip;
+  out.clip = view.worldViewProj * currentWorld;
   out.previousClip = view.temporalPreviousViewProj * previousWorld;
   out.uvAtlas = vertex.uvAtlas;
   return out;

package/src/sprite.wgsl

@@ -130,7 +130,7 @@ struct VsIn {
 };
 
 struct VsOut {
-  @builtin(position) clip     : vec4<f32>,
+  @builtin(position) @invariant clip     : vec4<f32>,
   // Atlas-space UV: already folded through region origin + size by the
   // vertex stage so the fragment can sample the bound material texture at
   // `in.uv_atlas` without any host-side region
@@ -310,7 +310,7 @@ fn fs_main_hdr(in : VsOut) -> @location(0) vec4<f32> {
 }
 
 struct TemporalVsOut {
-  @builtin(position) clip : vec4<f32>,
+  @builtin(position) @invariant clip : vec4<f32>,
   @location(0) uvAtlas : vec2<f32>,
   @location(1) @interpolate(perspective) currentClip : vec4<f32>,
   @location(2) @interpolate(perspective) previousClip : vec4<f32>,
@@ -328,7 +328,7 @@ fn vs_temporal(in : VsIn, @builtin(instance_index) idx : u32, @builtin(vertex_in
 #endif
   var out : TemporalVsOut;
   out.currentClip = view.temporalCurrentViewProj * currentWorld;
-  out.clip = out.currentClip;
+  out.clip = view.worldViewProj * currentWorld;
   out.previousClip = view.temporalPreviousViewProj * previousWorld;
   out.uvAtlas = vertex.uvAtlas;
   return out;

package/src/ssr-compose.wgsl

@@ -0,0 +1,129 @@
+#define_import_path forgeax_ssr::compose
+
+struct ComposeVertex {
+  @builtin(position) position : vec4<f32>,
+};
+
+@group(0) @binding(0) var radiance : texture_2d<f32>;
+@group(0) @binding(1) var fallback : texture_2d<f32>;
+@group(0) @binding(2) var response : texture_2d<f32>;
+@group(0) @binding(3) var normalRoughness : texture_2d<f32>;
+@group(0) @binding(4) var radianceSampler : sampler;
+#import forgeax_view::common::View
+@group(0) @binding(5) var<uniform> view : View;
+
+struct SsrReceiverSample {
+  radiance : vec4<f32>,
+  coverage : f32,
+};
+
+@vertex
+fn vs_ssr_compose(@builtin(vertex_index) index : u32) -> ComposeVertex {
+  let x = select(-1.0, 3.0, index == 1u);
+  let y = select(-1.0, 3.0, index == 2u);
+  return ComposeVertex(vec4<f32>(x, y, 0.0, 1.0));
+}
+
+// Reconstruct the half-resolution lattice without borrowing another face's
+// ray. Renormalize compatible taps instead of rejecting the entire pixel
+// solely because its nearest trace sample crossed a subpixel tile edge.
+fn ssrReceiverSample(uv : vec2<f32>, normal : vec3<f32>) -> SsrReceiverSample {
+  let size = vec2<i32>(textureDimensions(radiance, 0));
+  let coordinate = uv * vec2<f32>(size) - vec2<f32>(0.5);
+  let first = vec2<i32>(floor(coordinate));
+  let fraction = fract(coordinate);
+  var sum = vec4<f32>(0.0);
+  var totalWeight = 0.0;
+  let pixel00 = clamp(first + vec2<i32>(0, 0), vec2<i32>(0), size - vec2<i32>(1));
+  let tracedNormal00 = textureLoad(normalRoughness, pixel00 * 2, 0).xyz * 2.0 - vec3<f32>(1.0);
+  let weight00 = select(1.0 - fraction.x, fraction.x, false) * select(1.0 - fraction.y, fraction.y, false)
+    * ssrReceiverWeight(normal, tracedNormal00);
+  // The presentation pyramid is premultiplied by confidence. Preserve
+  // that representation during receiver reconstruction and unpremultiply
+  // only once after the roughness filter has selected its LOD.
+  let sample00 = textureLoad(radiance, pixel00, 0);
+  sum += sample00 * weight00;
+  totalWeight += weight00;
+
+  let pixel10 = clamp(first + vec2<i32>(1, 0), vec2<i32>(0), size - vec2<i32>(1));
+  let tracedNormal10 = textureLoad(normalRoughness, pixel10 * 2, 0).xyz * 2.0 - vec3<f32>(1.0);
+  let weight10 = select(1.0 - fraction.x, fraction.x, true) * select(1.0 - fraction.y, fraction.y, false)
+    * ssrReceiverWeight(normal, tracedNormal10);
+  let sample10 = textureLoad(radiance, pixel10, 0);
+  sum += sample10 * weight10;
+  totalWeight += weight10;
+
+  let pixel01 = clamp(first + vec2<i32>(0, 1), vec2<i32>(0), size - vec2<i32>(1));
+  let tracedNormal01 = textureLoad(normalRoughness, pixel01 * 2, 0).xyz * 2.0 - vec3<f32>(1.0);
+  let weight01 = select(1.0 - fraction.x, fraction.x, false) * select(1.0 - fraction.y, fraction.y, true)
+    * ssrReceiverWeight(normal, tracedNormal01);
+  let sample01 = textureLoad(radiance, pixel01, 0);
+  sum += sample01 * weight01;
+  totalWeight += weight01;
+
+  let pixel11 = clamp(first + vec2<i32>(1, 1), vec2<i32>(0), size - vec2<i32>(1));
+  let tracedNormal11 = textureLoad(normalRoughness, pixel11 * 2, 0).xyz * 2.0 - vec3<f32>(1.0);
+  let weight11 = select(1.0 - fraction.x, fraction.x, true) * select(1.0 - fraction.y, fraction.y, true)
+    * ssrReceiverWeight(normal, tracedNormal11);
+  let sample11 = textureLoad(radiance, pixel11, 0);
+  sum += sample11 * weight11;
+  totalWeight += weight11;
+  return SsrReceiverSample(sum / max(totalWeight, 1e-6), totalWeight);
+}
+
+fn ssrReflectionLod(roughness : f32) -> f32 {
+  return roughness * roughness * f32(textureNumLevels(radiance) - 1u);
+}
+
+fn sampleRoughSsr(uv : vec2<f32>, roughness : f32) -> vec4<f32> {
+  let lod = ssrReflectionLod(roughness);
+  // The presentation pyramid is premultiplied by confidence, so hardware
+  // bilinear/trilinear filtering preserves coverage without the four manual
+  // loads previously needed for every low-LOD sample.
+  return textureSampleLevel(radiance, radianceSampler, uv, lod);
+}
+
+fn ssrReceiverWeight(current : vec3<f32>, traced : vec3<f32>) -> f32 {
+  let agreement = dot(current, traced) * inverseSqrt(max(dot(current, current) * dot(traced, traced), 1e-8));
+  return smoothstep(0.9, 0.99, agreement);
+}
+
+@fragment
+fn fs_ssr_compose(in : ComposeVertex) -> @location(0) vec4<f32> {
+  let pixel = vec2<i32>(in.position.xy);
+  // Trace samples full-resolution pixel 2*p, not the center of a 2x2 box.
+  let uv = (in.position.xy + vec2<f32>(0.5)) / vec2<f32>(textureDimensions(fallback, 0));
+  let receiver = textureLoad(normalRoughness, pixel, 0);
+  let environment = textureLoad(fallback, pixel, 0);
+  let roughnessLimit = clamp(view.ssrParams.z, 0.0, 1.0);
+  if (!(view.ssrParams.w > 0.5 && view.ssrParams.w < 3.402823e+38) ||
+      !(receiver.a >= 0.0 && receiver.a < roughnessLimit) || environment.a <= 0.0) {
+    return vec4<f32>(0.0);
+  }
+  let reconstructed = ssrReceiverSample(uv, receiver.xyz * 2.0 - vec3<f32>(1.0));
+  if (reconstructed.coverage <= 1e-6) { return vec4<f32>(0.0); }
+  let base = reconstructed.radiance;
+  let roughness = clamp(receiver.a, 0.04, 1.0);
+  let lod = ssrReflectionLod(roughness);
+  var filtered = base;
+  if (lod < 1.0) {
+    // Preserve the normal-compatible receiver reconstruction at the sharp
+    // end while using one hardware-filtered read for the first roughness mip.
+    // This keeps the transition continuous at lod == 1 and avoids the four
+    // explicit footprint loads used by the old mip helper.
+    if (textureNumLevels(radiance) > 1u) {
+      filtered = mix(base, textureSampleLevel(radiance, radianceSampler, uv, 1.0), lod);
+    }
+  } else {
+    filtered = sampleRoughSsr(uv, roughness);
+  }
+  let sample = vec4<f32>(filtered.rgb / max(filtered.a, 1e-6), filtered.a);
+  let materialResponse = textureLoad(response, pixel, 0).rgb;
+  // Receiver admission is independent of the central mirror ray. A rough
+  // lobe can contain a visible wall even when that one ray misses its edge.
+  // Preserve the current material's cutoff instead of borrowing a neighbor's
+  // roughness policy from the filtered reflection pyramid.
+  let receiverConfidence = 1.0 - smoothstep(roughnessLimit * 0.8, roughnessLimit, receiver.a);
+  let confidence = clamp(min(receiverConfidence, sample.a), 0.0, 1.0) * environment.a;
+  return vec4<f32>(confidence * (sample.rgb * materialResponse - environment.rgb), 0.0);
+}

package/src/ssr-hiz-reduce.wgsl

@@ -0,0 +1,53 @@
+#define_import_path forgeax_ssr::hiz_reduce
+
+// Hi-Z reduction consumes the previous r32float mip.  It is deliberately a
+// separate module from the depth seed: WebGPU depth sample types cannot bind
+// an r32float view, while the seed must retain the depth-only binding.
+const SSR_HIZ_EMPTY_DEPTH : f32 = 3.402823e+38;
+
+@group(0) @binding(0) var sourceHiZ : texture_2d<f32>;
+@group(0) @binding(1) var hizOutput : texture_storage_2d<r32float, write>;
+
+fn isFinite(value : f32) -> bool {
+  return value == value && abs(value) < 3.402823e+38;
+}
+
+fn normalizeSsrHiZDepth(value : f32) -> f32 {
+  return select(SSR_HIZ_EMPTY_DEPTH, value, isFinite(value) && value > 0.0);
+}
+
+// Physical WebGPU mip dimensions are floor-halved. Partition the source by
+// integer normalized boundaries and ceil the end boundary so adjacent
+// footprints overlap at odd boundaries; a 3-wide source reduced to one texel
+// must inspect all three source texels rather than a clamped 2x2 prefix.
+fn reduceSsrHiZFootprint(
+  destinationCoordinate : vec2<u32>,
+  sourceSize : vec2<u32>,
+  destinationSize : vec2<u32>,
+) -> f32 {
+  let sourceStart = destinationCoordinate * sourceSize / destinationSize;
+  let sourceEnd = min(
+    ((destinationCoordinate + vec2<u32>(1u)) * sourceSize + destinationSize -
+      vec2<u32>(1u)) / destinationSize,
+    sourceSize,
+  );
+  var minimum = SSR_HIZ_EMPTY_DEPTH;
+  for (var y = sourceStart.y; y < sourceEnd.y; y += 1u) {
+    for (var x = sourceStart.x; x < sourceEnd.x; x += 1u) {
+      let depth = normalizeSsrHiZDepth(textureLoad(sourceHiZ, vec2<i32>(vec2<u32>(x, y)), 0).r);
+      minimum = min(minimum, depth);
+    }
+  }
+  return minimum;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn ssr_hiz_reduce(@builtin(global_invocation_id) globalId : vec3<u32>) {
+  let sourceSize = textureDimensions(sourceHiZ, 0);
+  let destinationSize = textureDimensions(hizOutput);
+  if (globalId.x >= destinationSize.x || globalId.y >= destinationSize.y) {
+    return;
+  }
+  let reduced = reduceSsrHiZFootprint(globalId.xy, sourceSize, destinationSize);
+  textureStore(hizOutput, vec2<i32>(globalId.xy), vec4<f32>(reduced, 0.0, 0.0, 1.0));
+}

package/src/ssr-hiz.wgsl

@@ -0,0 +1,66 @@
+#define_import_path forgeax_ssr::hiz
+
+// The SSR Hi-Z producer uses one r32float view for each graph mip.
+const SSR_HIZ_FORMAT : u32 = 1u;
+const SSR_HIZ_EMPTY_DEPTH : f32 = 3.402823e+38;
+
+@group(0) @binding(0) var sourceDepth : texture_depth_2d;
+@group(0) @binding(1) var hizOutput : texture_storage_2d<r32float, write>;
+#import forgeax_view::common::View
+@group(0) @binding(2) var<uniform> view : View;
+
+fn isFinite(value : f32) -> bool {
+  return value == value && abs(value) < 3.402823e+38;
+}
+
+// WebGPU depth attachments expose perspective depth, not a linear distance.
+// Hi-Z stores the positive view distance consumed by the bounded SSR ray
+// marcher. The shared View UBO carries the active projection range, so this
+// conversion does not create a second camera or projection owner.
+fn linearizeSsrDepth(value : f32) -> f32 {
+  if (!isFinite(value) || value <= 0.0 || value >= 1.0) {
+    return SSR_HIZ_EMPTY_DEPTH;
+  }
+  let near = view.temporalProjection.x;
+  let far = view.temporalProjection.y;
+  if (!isFinite(near) || !isFinite(far) || near <= 0.0 || far <= near) {
+    return SSR_HIZ_EMPTY_DEPTH;
+  }
+  let orthographic = view.temporalProjection.z > 0.5;
+  let distance = select(
+    (near * far) / max(far - value * (far - near), 1e-5),
+    near + value * (far - near),
+    orthographic,
+  );
+  return select(SSR_HIZ_EMPTY_DEPTH, distance, isFinite(distance) && distance > 0.0);
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn ssr_hiz_seed(@builtin(global_invocation_id) globalId : vec3<u32>) {
+  let sourceSize = textureDimensions(sourceDepth, 0);
+  let outputSize = textureDimensions(hizOutput);
+  if (any(globalId.xy >= outputSize)) {
+    return;
+  }
+  // Match the reduction coverage contract: floor the start and ceil the end
+  // so an odd source boundary is conservatively present in both neighbors.
+  let first = globalId.xy * sourceSize / outputSize;
+  let end = min(
+    ((globalId.xy + vec2<u32>(1u)) * sourceSize + outputSize - vec2<u32>(1u)) /
+      outputSize,
+    sourceSize,
+  );
+  var nearestDepth = 1.0;
+  for (var y = first.y; y < end.y; y++) {
+    for (var x = first.x; x < end.x; x++) {
+      let sample = textureLoad(sourceDepth, vec2<i32>(vec2<u32>(x, y)), 0);
+      if (isFinite(sample) && sample > 0.0 && sample < 1.0) {
+        nearestDepth = min(nearestDepth, sample);
+      }
+    }
+  }
+  // Both supported depth projections are monotonic, so linearize once after
+  // selecting the nearest valid source sample.
+  let depth = linearizeSsrDepth(nearestDepth);
+  textureStore(hizOutput, vec2<i32>(globalId.xy), vec4<f32>(depth, 0.0, 0.0, 1.0));
+}