1 files changed, 31 insertions, 23 deletions

diff --git a/cnn_v3/shaders/gbuf_raster.wgsl b/cnn_v3/shaders/gbuf_raster.wgsl
index c762db2..aed0e72 100644
--- a/cnn_v3/shaders/gbuf_raster.wgsl
+++ b/cnn_v3/shaders/gbuf_raster.wgsl
@@ -1,8 +1,11 @@
 // G-buffer rasterization shader for CNN v3
 // Pass 1: Proxy geometry → MRT (albedo rgba16float, normal_mat rgba16float, depth32)
 // Uses GlobalUniforms, ObjectData, ObjectsBuffer from common_uniforms.
+// SPHERE objects use ray-sphere impostor (correct silhouette + normal + depth).
 
 #include "common_uniforms"
+#include "math/normal"
+#include "ray_sphere"
 
 @group(0) @binding(0) var<uniform> globals: GlobalUniforms;
 @group(0) @binding(1) var<storage, read> object_data: ObjectsBuffer;
@@ -15,21 +18,6 @@ struct VertexOutput {
     @location(3) @interpolate(flat) instance_index: u32,
 }
 
-// Octahedral encoding: maps unit normal to [-1,1]^2
-fn oct_encode(n: vec3f) -> vec2f {
-    let inv_l1 = 1.0 / (abs(n.x) + abs(n.y) + abs(n.z));
-    var p = n.xy * inv_l1;
-    // Fold lower hemisphere
-    if (n.z < 0.0) {
-        let s = vec2f(
-            select(-1.0, 1.0, p.x >= 0.0),
-            select(-1.0, 1.0, p.y >= 0.0)
-        );
-        p = (1.0 - abs(p.yx)) * s;
-    }
-    return p; // in [-1, 1]
-}
-
 @vertex
 fn vs_main(
     @builtin(vertex_index)   vertex_index:   u32,
@@ -73,8 +61,8 @@ fn vs_main(
 
     let world_pos    = obj.model * vec4f(p, 1.0);
     let clip_pos     = globals.view_proj * world_pos;
-    // Transform normal by inverse-transpose (upper-left 3×3 of inv_model^T)
-    let world_normal = normalize((obj.inv_model * vec4f(n, 0.0)).xyz);
+    // Transform normal: use model matrix (correct for uniform scale + rotation).
+    let world_normal = normalize((obj.model * vec4f(n, 0.0)).xyz);
 
     var out: VertexOutput;
     out.position       = clip_pos;
@@ -86,20 +74,40 @@ fn vs_main(
 }
 
 struct GBufOutput {
-    @location(0) albedo:     vec4f,  // rgba16float: material color
-    @location(1) normal_mat: vec4f,  // rgba16float: oct-normal XY in RG, mat_id/255 in B
+    @location(0)            albedo:     vec4f,  // rgba16float: material color
+    @location(1)            normal_mat: vec4f,  // rgba16float: oct-normal XY in RG, mat_id/255 in B
+    @builtin(frag_depth)    depth:      f32,    // corrected depth (sphere impostor)
 }
 
 @fragment
 fn fs_main(in: VertexOutput) -> GBufOutput {
-    let obj    = object_data.objects[in.instance_index];
-    let mat_id = f32(in.instance_index) / 255.0;
+    let obj      = object_data.objects[in.instance_index];
+    let obj_type = u32(obj.params.x);
+    let mat_id   = f32(in.instance_index) / 255.0;
+
+    var world_normal = normalize(in.world_normal);
+    var frag_depth   = in.position.z;  // default: hardware depth
+
+    // Sphere impostor: ray-sphere intersection for correct silhouette and normal.
+    if (obj_type == 1u) {
+        let sphere_center = obj.model[3].xyz;
+        let sphere_radius = length(obj.model[0].xyz);  // uniform scale in col0
+        let cam_pos = globals.camera_pos_time.xyz;
+        let rd = normalize(in.world_pos - cam_pos);
+        let isect = ray_sphere_intersection(cam_pos, rd, sphere_center, sphere_radius);
+        if (!isect.hit) { discard; }
+        let hit = cam_pos + rd * isect.t;
+        world_normal = normalize(hit - sphere_center);
+        // Reproject hit point to get correct clip-space depth.
+        let clip_hit = globals.view_proj * vec4f(hit, 1.0);
+        frag_depth   = clip_hit.z / clip_hit.w;
+    }
 
-    // Oct-encode world normal, remap [-1,1] → [0,1] for storage
-    let oct = oct_encode(normalize(in.world_normal)) * 0.5 + vec2f(0.5);
+    let oct = oct_encode_unorm(world_normal);
 
     var out: GBufOutput;
     out.albedo     = vec4f(in.color.rgb, 1.0);
     out.normal_mat = vec4f(oct.x, oct.y, mat_id, 0.0);
+    out.depth      = frag_depth;
     return out;
 }