From 7b89a7130a998017de98dde363a8d9be61d7d44e Mon Sep 17 00:00:00 2001
From: skal <pascal.massimino@gmail.com>
Date: Sun, 22 Mar 2026 19:29:01 +0100
Subject: feat(cnn_v3): GBufferEffect Pass 2 — SDF shadow raymarching
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implements gbuf_shadow.wgsl: fullscreen render pass that reads depth
from Pass 1, reconstructs world-space positions, evaluates a proxy-box
SDF for each object (via inv_model), computes soft shadows for both
directional lights using shadowWithStoredDistance(), and writes shadow
factor to the RGBA8Unorm node_shadow_ target consumed by gbuf_pack.wgsl.

Bind layout: B0=GlobalUniforms, B1=ObjectsBuffer (storage-read),
B2=texture_depth_2d, B3=GBufLightsUniforms.
Sky fragments (depth=1.0) are output as 1.0 (fully lit).
Falls back to clear(1.0) if pipeline is not ready.

36/36 tests pass.

handoff(Gemini): Pass 2 done. Pass 3 (transparency) still TODO.
Phase 4 (type-aware SDF) optional after visual validation.
---
 cnn_v3/shaders/gbuf_shadow.wgsl | 92 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 92 insertions(+)
 create mode 100644 cnn_v3/shaders/gbuf_shadow.wgsl

(limited to 'cnn_v3/shaders')

diff --git a/cnn_v3/shaders/gbuf_shadow.wgsl b/cnn_v3/shaders/gbuf_shadow.wgsl
new file mode 100644
index 0000000..36e7b28
--- /dev/null
+++ b/cnn_v3/shaders/gbuf_shadow.wgsl
@@ -0,0 +1,92 @@
+// G-buffer shadow raymarching shader for CNN v3
+// Pass 2: Reads depth from Pass 1, marches shadow rays toward lights,
+// outputs shadow factor (1.0=lit, 0.0=shadow) to RGBA8Unorm render target (.r).
+
+#include "common_uniforms"
+#include "camera_common"
+#include "math/sdf_shapes"
+#include "render/raymarching_id"
+
+@group(0) @binding(0) var<uniform>         globals:     GlobalUniforms;
+@group(0) @binding(1) var<storage, read>   object_data: ObjectsBuffer;
+@group(0) @binding(2) var                  depth_tex:   texture_depth_2d;
+
+struct GBufLight {
+    direction: vec4f,  // xyz = toward light (world space, normalized)
+    color:     vec4f,  // rgb = color, a = intensity
+}
+struct GBufLightsUniforms {
+    lights: array<GBufLight, 2>,
+    params: vec4f,  // x = num_lights
+}
+@group(0) @binding(3) var<uniform> lights: GBufLightsUniforms;
+
+// ---- SDF scene (proxy box per object in local space) ----
+
+// Stub required by render/raymarching (shadow() / rayMarch() call df()).
+fn df(p: vec3f) -> f32 { return MAX_RAY_LENGTH; }
+
+// SDF of the full scene: proxy box for each object transformed to local space.
+fn dfWithID(p: vec3f) -> RayMarchResult {
+    var res: RayMarchResult;
+    res.distance     = MAX_RAY_LENGTH;
+    res.distance_max = MAX_RAY_LENGTH;
+    res.object_id    = 0.0;
+
+    let n = u32(globals.params.x);
+    for (var i = 0u; i < n; i++) {
+        let obj = object_data.objects[i];
+        let lp  = (obj.inv_model * vec4f(p, 1.0)).xyz;
+        let d   = sdBox(lp, vec3f(1.0));
+        if (d < res.distance) {
+            res.distance  = d;
+            res.object_id = f32(i + 1u);
+        }
+    }
+    return res;
+}
+
+// ---- Vertex: fullscreen triangle ----
+
+@vertex
+fn vs_main(@builtin(vertex_index) vid: u32) -> @builtin(position) vec4f {
+    let x = f32((vid & 1u) << 2u) - 1.0;
+    let y = f32((vid & 2u) << 1u) - 1.0;
+    return vec4f(x, y, 0.0, 1.0);
+}
+
+// ---- Fragment: shadow factor per pixel ----
+
+@fragment
+fn fs_main(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+    let depth = textureLoad(depth_tex, vec2i(pos.xy), 0);
+
+    // Sky / background: fully lit.
+    if (depth >= 1.0) {
+        return vec4f(1.0);
+    }
+
+    // Reconstruct world-space position from NDC + depth.
+    let res = globals.resolution;
+    let ndc = vec2f(
+        (pos.x / res.x) * 2.0 - 1.0,
+        1.0 - (pos.y / res.y) * 2.0
+    );
+    let clip  = globals.inv_view_proj * vec4f(ndc, depth, 1.0);
+    let world = clip.xyz / clip.w;
+
+    // Surface normal estimated from SDF gradient.
+    let nor      = normalWithID(world);
+    let bias_pos = world + nor * 0.02;
+
+    // March shadow rays toward each light; take the darkest value.
+    var shadow_val  = 1.0;
+    let num_lights  = u32(lights.params.x);
+    for (var i = 0u; i < num_lights; i++) {
+        let ld = lights.lights[i].direction.xyz;
+        let s  = shadowWithStoredDistance(bias_pos, ld, MAX_RAY_LENGTH);
+        shadow_val = min(shadow_val, s);
+    }
+
+    return vec4f(shadow_val, shadow_val, shadow_val, 1.0);
+}
-- 
cgit v1.2.3