@woosh/meep-engine 3.61.2 → 3.62.0

package/src/engine/graphics3/shader_picking_gather.js

@@ -1,120 +1,133 @@
-import {
-    VIZ_BUFFER_INVALID_MESH_VALUE
-} from "../../shade/renderer/rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
-import { CodeChunk } from "../../shade/renderer/shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shade/renderer/shader/ComputeShader.js";
-import {
-    ShaderResourceSetDescriptor
-} from "../../shade/renderer/shader/resource/ShaderResourceSetDescriptor.js";
-import { u32 } from "../../shade/renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shade/renderer/shader/type/WebGPUArray.js";
-
-/**
- * Words a query occupies, on the way in and on the way back: a pixel's x and y going in, the mesh
- * row and the depth's bit pattern coming out.
- *
- * @type {number}
- */
-export const PICKING_GATHER_STRIDE_WORDS = 2;
-
-/**
- * The `x` of a query whose point is not on the view at all.
- *
- * A pick names a fraction of the view and a caller is free to ask outside it, so a query carries
- * either a pixel or this. No pixel can collide with it: `maxTextureDimension2D` is nowhere near
- * 2^32 - 1 in any WebGPU profile, so there is no view this is a column of.
- *
- * @type {number}
- */
-export const PICKING_QUERY_OFF_VIEW = 0xFFFFFFFF;
-
-/**
- * @type {number}
- */
-export const PICKING_GATHER_WORKGROUP_SIZE = 64;
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer
-resources.setImmediate("query_count", u32);
-
-resources.createGroup()
-    // The frame's visibility buffer — the `meshes` row the rasterizer wrote at each pixel — and the
-    // depth it wrote with it. Both are read as *bindings*, which is the whole reason this pass is a
-    // dispatch: see the note on {@link shader_picking_gather}.
-    .addTexture("viz_mesh", "uint")
-    .addTexture("viz_depth", "depth");
-
-resources.createGroup()
-    // x, y per query; `PICKING_QUERY_OFF_VIEW` in x for a query that is off the view
-    .addStorageBuffer("queries", WebGPUArray.u32)
-    // mesh row, then the depth's bits, per query
-    .addStorageBuffer("results", WebGPUArray.u32, true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const PICKING_STRIDE : u32 = ${PICKING_GATHER_STRIDE_WORDS}u;
-const PICKING_OFF_VIEW : u32 = ${PICKING_QUERY_OFF_VIEW}u;
-const PICKING_VIZ_INVALID : u32 = ${VIZ_BUFFER_INVALID_MESH_VALUE}u;
-
-@compute @workgroup_size(${PICKING_GATHER_WORKGROUP_SIZE},1,1)
-fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
-    let index = gid.x;
-
-    /*
-     The dispatch is sized to ceil(query_count / 64) workgroups, so the tail carries up to 63 idle
-     threads. Guarded on the immediate rather than on arrayLength: both buffers come from the
-     transient pool, which matches approximately, so their lengths are pool state rather than the
-     number of queries — a thread past the end would read a previous tenant's pixel and write a row
-     nobody asked for.
-    */
-    if index >= query_count {
-        return;
-    }
-
-    let base = index * PICKING_STRIDE;
-
-    let x = queries[base];
-    let y = queries[base + 1u];
-
-    /*
-     Every slot is written, the off-view ones included. A pooled buffer arrives carrying whatever its
-     last tenant left, and a query off the view has to read back as nothing rather than as that — so
-     the pass defines the whole of its output instead of a clear being encoded ahead of it.
-    */
-    if x == PICKING_OFF_VIEW {
-        results[base] = PICKING_VIZ_INVALID;
-        results[base + 1u] = 0u;
-
-        return;
-    }
-
-    let at = vec2<i32>(i32(x), i32(y));
-
-    results[base] = textureLoad(viz_mesh, at, 0).r;
-    results[base + 1u] = bitcast<u32>(textureLoad(viz_depth, at, 0));
-}
-`);
-
-/**
- * Reads the visibility buffer's mesh row and the frame's depth at a handful of pixels, into a
- * buffer small enough to read back on a click.
- *
- * **A dispatch rather than a copy, twice over.** The obvious shape for this is
- * `copyTextureToBuffer` of a 1x1 region per query, and it is not legal WebGPU for either texture.
- * The visibility buffer is a render attachment the renderer never gave `COPY_SRC` — and should not
- * have to, since the flag is for the whole frame and a pick happens on a click — while a depth
- * format may not be sub-region copied **at all**: "if the format is a depth-or-stencil format [...]
- * the subresource size is equal to size", so the only legal copy of a 1065x1668 depth buffer is all
- * 7 MB of it. Both textures are already `TEXTURE_BINDING`, because the frame shades from them, and
- * `textureLoad` has neither restriction.
- *
- * One thread per query. Nothing is sampled, filtered or interpolated: the answer has to be the row
- * the rasterizer wrote at that exact pixel, which is what makes a pick as precise as the frame.
- */
-export const shader_picking_gather = ComputeShader.from({
-    label: "Picking/Gather",
-    resources,
-    body,
-});
+import {
+    VIZ_BUFFER_INVALID_MESH_VALUE
+} from "../../shade/renderer/rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+import {
+    chunk_visibility_decode,
+    VISIBLE_MESHLETS_RESOURCE
+} from "../../shade/renderer/rasterize/visibility/chunk_visibility_decode.js";
+import { CodeChunk } from "../../shade/renderer/shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shade/renderer/shader/ComputeShader.js";
+import {
+    ShaderResourceSetDescriptor
+} from "../../shade/renderer/shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../shade/renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shade/renderer/shader/type/WebGPUArray.js";
+
+/**
+ * Words a query occupies, on the way in and on the way back: a pixel's x and y going in, the mesh
+ * row and the depth's bit pattern coming out.
+ *
+ * @type {number}
+ */
+export const PICKING_GATHER_STRIDE_WORDS = 2;
+
+/**
+ * The `x` of a query whose point is not on the view at all.
+ *
+ * A pick names a fraction of the view and a caller is free to ask outside it, so a query carries
+ * either a pixel or this. No pixel can collide with it: `maxTextureDimension2D` is nowhere near
+ * 2^32 - 1 in any WebGPU profile, so there is no view this is a column of.
+ *
+ * @type {number}
+ */
+export const PICKING_QUERY_OFF_VIEW = 0xFFFFFFFF;
+
+/**
+ * @type {number}
+ */
+export const PICKING_GATHER_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("query_count", u32);
+
+resources.createGroup()
+    // The frame's visibility buffer, with the table that resolves each pixel to the `meshes` row it was
+    // drawn for, and the depth written with it. Read as *bindings*, which is the whole reason this pass
+    // is a dispatch: see the note on {@link shader_picking_gather}.
+    .addTexture("visibility", "uint")
+    .add(VISIBLE_MESHLETS_RESOURCE)
+    .addTexture("viz_depth", "depth");
+
+resources.createGroup()
+    // x, y per query; `PICKING_QUERY_OFF_VIEW` in x for a query that is off the view
+    .addStorageBuffer("queries", WebGPUArray.u32)
+    // mesh row, then the depth's bits, per query
+    .addStorageBuffer("results", WebGPUArray.u32, true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const PICKING_STRIDE : u32 = ${PICKING_GATHER_STRIDE_WORDS}u;
+const PICKING_OFF_VIEW : u32 = ${PICKING_QUERY_OFF_VIEW}u;
+const PICKING_VIZ_INVALID : u32 = ${VIZ_BUFFER_INVALID_MESH_VALUE}u;
+
+@compute @workgroup_size(${PICKING_GATHER_WORKGROUP_SIZE},1,1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let index = gid.x;
+
+    /*
+     The dispatch is sized to ceil(query_count / 64) workgroups, so the tail carries up to 63 idle
+     threads. Guarded on the immediate rather than on arrayLength: both buffers come from the
+     transient pool, which matches approximately, so their lengths are pool state rather than the
+     number of queries — a thread past the end would read a previous tenant's pixel and write a row
+     nobody asked for.
+    */
+    if index >= query_count {
+        return;
+    }
+
+    let base = index * PICKING_STRIDE;
+
+    let x = queries[base];
+    let y = queries[base + 1u];
+
+    /*
+     Every slot is written, the off-view ones included. A pooled buffer arrives carrying whatever its
+     last tenant left, and a query off the view has to read back as nothing rather than as that — so
+     the pass defines the whole of its output instead of a clear being encoded ahead of it.
+    */
+    if x == PICKING_OFF_VIEW {
+        results[base] = PICKING_VIZ_INVALID;
+        results[base + 1u] = 0u;
+
+        return;
+    }
+
+    let at = vec2<i32>(i32(x), i32(y));
+
+    let word = textureLoad(visibility, at, 0).r;
+
+    var row = PICKING_VIZ_INVALID;
+
+    if word != VISIBILITY_NONE {
+        row = visibility_decode(word).mesh;
+    }
+
+    results[base] = row;
+    results[base + 1u] = bitcast<u32>(textureLoad(viz_depth, at, 0));
+}
+`, [chunk_visibility_decode]);
+
+/**
+ * Reads the visibility buffer's mesh row and the frame's depth at a handful of pixels, into a
+ * buffer small enough to read back on a click.
+ *
+ * **A dispatch rather than a copy, twice over.** The obvious shape for this is
+ * `copyTextureToBuffer` of a 1x1 region per query, and it is not legal WebGPU for either texture.
+ * The visibility buffer is a render attachment the renderer never gave `COPY_SRC` — and should not
+ * have to, since the flag is for the whole frame and a pick happens on a click — while a depth
+ * format may not be sub-region copied **at all**: "if the format is a depth-or-stencil format [...]
+ * the subresource size is equal to size", so the only legal copy of a 1065x1668 depth buffer is all
+ * 7 MB of it. Both textures are already `TEXTURE_BINDING`, because the frame shades from them, and
+ * `textureLoad` has neither restriction.
+ *
+ * One thread per query. Nothing is sampled, filtered or interpolated: the answer has to be the row
+ * the rasterizer wrote at that exact pixel, which is what makes a pick as precise as the frame.
+ */
+export const shader_picking_gather = ComputeShader.from({
+    label: "Picking/Gather",
+    resources,
+    body,
+});

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -66,11 +66,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#486@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#488@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#486@#clear_field"(fluid: FluidComponent): void;
+    static "__#488@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -82,7 +82,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#486@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#488@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -102,7 +102,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#486@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#488@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof FluidObstacle> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof FluidComponent>)[];

package/src/shade/device/mock/SoftwareGPUTexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTexture.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,yEAFgB,UAAU;IAkEtB;;;;;;OAMG;IACH,6EAFa,kBAAkB,CAI9B;IAnCD;;;;OAIG;IACH,iFAFW,OAAO,EAqBjB;IAzDD;;;;;;OAMG;IACH,uBAEC;IAuCG,WAAuC;IACvC,YAAyC;IACzC,wBAAiE;IAEjE,YAA+B;IAC/B,eAA6C;IAC7C,WAA6B;IAC7B,iBAA8C;IAC9C,mBAAkD;IActD;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAEC;IAED;;;;;;;;;OASG;IACH,8BAUC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,WAAW,CAgBvB;IAED;;;;;;;;;;;;;OAaG;IACH,kEAUC;IAwCD;;;OAGG;IACH,gBAOC;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;;CANhD;sCAlRqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPUTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTexture.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,yEAFgB,UAAU;IAkEtB;;;;;;OAMG;IACH,6EAFa,kBAAkB,CAI9B;IAnCD;;;;OAIG;IACH,iFAFW,OAAO,EAqBjB;IAzDD;;;;;;OAMG;IACH,uBAEC;IAuCG,WAAuC;IACvC,YAAyC;IACzC,wBAAiE;IAEjE,YAA+B;IAC/B,eAA6C;IAC7C,WAA6B;IAC7B,iBAA8C;IAC9C,mBAAkD;IActD;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAEC;IAED;;;;;;;;;OASG;IACH,8BAUC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,WAAW,CAgBvB;IAED;;;;;;;;;;;;;OAaG;IACH,kEAUC;IAmDD;;;OAGG;IACH,gBAOC;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;;CANhD;sCA7RqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUTexture.js

@@ -266,6 +266,17 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
                 + ` nor one of its viewFormats (${this.#view_formats.join(', ') || 'none'})`;
         }
 
+        /*
+         The levels a view covers must be levels the texture has: at least one, all of them below its
+         mipLevelCount. An unset count is every level from the base on.
+        */
+        const base_mip_level = descriptor?.baseMipLevel ?? 0;
+        const mip_level_count = descriptor?.mipLevelCount ?? (this.mipLevelCount - base_mip_level);
+
+        if (mip_level_count < 1 || base_mip_level + mip_level_count > this.mipLevelCount) {
+            return `levels ${base_mip_level} to ${base_mip_level + mip_level_count - 1} of '${this.label}', which has ${this.mipLevelCount}`;
+        }
+
         return null;
     }
 

package/src/shade/device/pipeline/rp_validate_and_rewrite_for_color_attachments.js

@@ -48,7 +48,7 @@ for (const tuple of compatible_tuples) {
  */
 function is_compatible(a, b) {
     // Identical formats are always compatible — including formats with no tuple entry (e.g. the
-    // gbuffer's rgba16uint / r32uint), which the rewrite loop still checks when some OTHER target
+    // gbuffer's r32uint targets), which the rewrite loop still checks when some OTHER target
     // triggered a rewrite. Guard the lookup so an unlisted source is treated as incompatible and
     // reaches the descriptive error below, rather than throwing a raw TypeError.
     if (a === b) {

package/src/shade/playground/contact_shadows/ContactShadowLab.js

@@ -344,7 +344,7 @@ export class ContactShadowLab {
                         step_count: this.march_steps,
                     },
                     gBufferDepth: depth,
-                    gBufferNormal: gbuffer.normal,
+                    gBufferPBR: gbuffer.pbr,
                     camera: view.camera.buffer,
                     tContactShadow: TextureResourceDescriptor.from({
                         resolution: [width, height],
@@ -363,7 +363,7 @@ export class ContactShadowLab {
             contact = graph_contact_shadow_linear({
                 graph,
                 depth,
-                normal: gbuffer.normal,
+                pbr: gbuffer.pbr,
                 camera: view.camera.buffer,
                 resolution,
                 settings,
@@ -372,7 +372,7 @@ export class ContactShadowLab {
 
         const traced = this.reference || this.measuring;
 
-        const reference = traced ? this.#record_reference(graph, view, depth, gbuffer.normal, width, height) : -1;
+        const reference = traced ? this.#record_reference(graph, view, depth, gbuffer.pbr, width, height) : -1;
 
         let flags = 0;
 
@@ -427,7 +427,7 @@ export class ContactShadowLab {
      * One ray per pixel from its G-buffer position toward the sun, through the scene's BVH
      * ({@link shader_contact_lab_reference}): visibility, 1 lit and 0 shadowed.
      */
-    #record_reference(graph, view, depth, normal, width, height) {
+    #record_reference(graph, view, depth, pbr, width, height) {
         const data = {};
         const pass = graph.add('Contact lab / ray-traced reference', data, (data, resources, context) => {
             const scene_ctx = view.scene;
@@ -444,7 +444,7 @@ export class ContactShadowLab {
                 bindings: {
                     settings: { normal_offset: this.reference_normal_offset },
                     gBufferDepth: resources.get(data.depth).obtainView(MIP_0),
-                    gBufferNormal: resources.get(data.normal).obtainView(MIP_0),
+                    gBufferPBR: resources.get(data.pbr).obtainView(MIP_0),
                     camera: view.camera.buffer,
                     view: view.uniform_buffer,
                     tlas: scene_ctx.tlas.buffer,
@@ -463,7 +463,7 @@ export class ContactShadowLab {
         });
 
         data.depth = pass.read(depth);
-        data.normal = pass.read(normal);
+        data.pbr = pass.read(pbr);
         data.output = pass.create('contact lab / reference', TextureResourceDescriptor.from({
             resolution: [width, height],
             format: 'r32float',

package/src/shade/playground/contact_shadows/shader_contact_lab_composite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_contact_lab_composite.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_lab_composite.js"],"names":[],"mappings":";;;6BA4BU,MAAM;;;;;;;;;oCAgBN,MAAM;;;;;AAwKhB;;;;;;;;;;;;;;;GAeG;AACH,2CAFU,WAAW,CAkBlB;4BArOyB,sCAAsC"}
+{"version":3,"file":"shader_contact_lab_composite.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_lab_composite.js"],"names":[],"mappings":";;;6BA+BU,MAAM;;;;;;;;;oCAgBN,MAAM;;;;;AAuKhB;;;;;;;;;;;;;;;GAeG;AACH,2CAFU,WAAW,CAkBlB;4BApOyB,sCAAsC"}

package/src/shade/playground/contact_shadows/shader_contact_lab_composite.js

@@ -4,6 +4,9 @@ import { chunk_project_position_from_depth } from "../../renderer/shader/chunk/c
 import { chunk_is_background } from "../../renderer/shader/chunk/depth/chunk_is_background.js";
 import { chunk_mat4_extract_position } from "../../renderer/shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_decode_g_buffer_normal } from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { chunk_directional_lights_iteration_mask } from "../../renderer/shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
 import { chunk_get_directional_light_info_by_index } from "../../renderer/shader/chunk/light/io/chunk_get_directional_light_info_by_index.js";
 import { REFLECTED_LIGHT_STRUCT } from "../../renderer/shader/chunk/light/REFLECTED_LIGHT_STRUCT.js";
@@ -123,11 +126,9 @@ fn main(
     let position_ws = project_position_from_depth(uv, texel_depth, camera.view_projection_matrix_inverse);
     let view_direction = normalize(mat4_extract_position(camera.transform) - position_ws);
 
-    let g_buffer_sample_normal = textureLoad(gBufferNormal, i_coord, 0);
-
     let geometry = ${GEOMETRIC_SHADING_INFO_STRUCT.wgsl_ref}(
-        decode_g_buffer_normal(g_buffer_sample_normal.xy),
-        decode_g_buffer_normal(g_buffer_sample_normal.zw),
+        decode_g_buffer_normal(textureLoad(gBufferNormal, i_coord, 0).x),
+        decode_g_buffer_face_normal(textureLoad(gBufferPBR, i_coord, 0)),
         position_ws,
         view_direction,
     );
@@ -201,6 +202,7 @@ fn main(
         chunk_project_position_from_depth,
         chunk_mat4_extract_position,
         chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_read_gBuffer_material,
         chunk_directional_lights_iteration_mask,
         chunk_get_directional_light_info_by_index,

package/src/shade/playground/contact_shadows/shader_contact_lab_reference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_contact_lab_reference.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_lab_reference.js"],"names":[],"mappings":"AAuGA;;;;;;;;;;;GAWG;AACH,2CAFU,aAAa,CAMpB;8BAxG2B,wCAAwC"}
+{"version":3,"file":"shader_contact_lab_reference.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_lab_reference.js"],"names":[],"mappings":"AAyGA;;;;;;;;;;;GAWG;AACH,2CAFU,aAAa,CAMpB;8BAxG2B,wCAAwC"}

package/src/shade/playground/contact_shadows/shader_contact_lab_reference.js

@@ -4,7 +4,9 @@ import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../../renderer/material/resident/I
 import { chunk_ray_shaded_query_occluded } from "../../renderer/path_tracer/shader/chunk_ray_shaded_query_occluded.js";
 import { chunk_project_position_from_depth } from "../../renderer/shader/chunk/camera/chunk_project_position_from_depth.js";
 import { chunk_is_background } from "../../renderer/shader/chunk/depth/chunk_is_background.js";
-import { chunk_decode_g_buffer_normal } from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { chunk_offset_ray } from "../../renderer/shader/chunk/geometry/ray/chunk_offset_ray.js";
 import { RAY_STRUCT } from "../../renderer/shader/chunk/geometry/ray/RAY_STRUCT.js";
 import { chunk_directional_lights_iteration_mask } from "../../renderer/shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
@@ -38,7 +40,7 @@ resources.createGroup()
 
 resources.createGroup()
     .addTexture("gBufferDepth")
-    .addTexture("gBufferNormal", "uint")
+    .addTexture("gBufferPBR")
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addUniform("view", VIEW_UNIFORM_STRUCT)
     .addStorageTexture("tReference", "r32float", "2d", "write-only");
@@ -66,7 +68,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     if (!is_background(depth) && directional_bits != 0u) {
         let uv = texel_coordinate_to_uv(vec2<f32>(id.xy), size);
         let position_ws = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
-        let geometric_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, id.xy, 0).zw);
+        let geometric_normal = decode_g_buffer_face_normal(textureLoad(gBufferPBR, id.xy, 0));
 
         let sun = get_directional_light_info_by_index(&light_data, countTrailingZeros(directional_bits));
 
@@ -93,7 +95,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
         chunk_is_background,
         chunk_texel_coordinate_to_uv,
         chunk_project_position_from_depth,
-        chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_offset_ray,
         chunk_directional_lights_iteration_mask,
         chunk_get_directional_light_info_by_index,

package/src/shade/playground/contact_shadows/shader_contact_shadow_march.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_contact_shadow_march.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_shadow_march.js"],"names":[],"mappings":"AA6EA;;;;;;;GAOG;AACH,0CAFU,aAAa,CAMpB;8BAjF2B,wCAAwC"}
+{"version":3,"file":"shader_contact_shadow_march.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_shadow_march.js"],"names":[],"mappings":"AA+EA;;;;;;;GAOG;AACH,0CAFU,aAAa,CAMpB;8BAjF2B,wCAAwC"}

package/src/shade/playground/contact_shadows/shader_contact_shadow_march.js

@@ -3,7 +3,9 @@ import { chunk_ss_trace_pixel_occlusion } from "../../renderer/deferred/chunk_ss
 import { chunk_project_position_from_depth } from "../../renderer/shader/chunk/camera/chunk_project_position_from_depth.js";
 import { chunk_get_view_space_depth } from "../../renderer/shader/chunk/depth/chunk_get_view_space_depth.js";
 import { chunk_is_background } from "../../renderer/shader/chunk/depth/chunk_is_background.js";
-import { chunk_decode_g_buffer_normal } from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { chunk_texel_coordinate_to_uv } from "../../renderer/shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
 import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../renderer/shader/ComputeShader.js";
@@ -23,7 +25,7 @@ resources.setImmediate("settings", SETTINGS);
 
 resources.createGroup()
     .addTexture("gBufferDepth")
-    .addTexture("gBufferNormal", "uint")
+    .addTexture("gBufferPBR")
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addStorageTexture("tContactShadow", "r32float", "2d", "write-only");
 
@@ -47,7 +49,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
 
     let uv = texel_coordinate_to_uv(vec2<f32>(id.xy), size);
     let position_ws = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
-    let geometric_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, id.xy, 0).zw);
+    let geometric_normal = decode_g_buffer_face_normal(textureLoad(gBufferPBR, id.xy, 0));
 
     // the same window as the wavefront pass: an occluder may sit up to 2 × thickness × its distance in front
     let thickness = 2.0 * settings.surface_thickness * get_view_space_depth(depth, camera);
@@ -70,7 +72,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
         chunk_texel_coordinate_to_uv,
         chunk_project_position_from_depth,
         chunk_get_view_space_depth,
-        chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_ss_trace_pixel_occlusion,
     ]
 );

package/src/shade/playground/probe_clipmap/README.md

@@ -21,7 +21,7 @@ has the two lines that put it there. Another scene loads with `?scene=/some/othe
 | control | what it does |
 |---|---|
 | Indirect light | the probe clipmap, or IBL to compare against |
-| Debug view | the brick clipmap as the probes' rays see it; the geometry caches' mesh SDF; the hits' albedo from the cards |
+| Debug view | the brick clipmap as the probes' rays see it; the geometry caches' mesh SDF; the hits' albedo from the meshes' surface caches; the brick material the probes' hits read; the light the probes' indirect diffuse (irradiance / π) or indirect specular (radiance) is made of, before the surface's albedo, metalness, reflectance and occlusion, through the frame's TAA and exposure |
 | Path tracer (P) | the accumulating path tracer's image in place of the rasterized one, as ground truth; TAA is off while it is on and comes back after |
 | History re-sampling (R) | each probe update pools its rays with what four of its neighbours have already seen, where their depth confirms it (`ProbeClipmapSettings.history_resampling`); off by default, and measured quieter but no faster to converge on Sponza (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8) |
 | Ray re-sampling (T) | each probe update also takes every ray one neighbour traced the same frame, the neighbour drawn by its radiance and the probe's sight of it, each ray where the probe's depth confirms its hit or sky (`ProbeClipmapSettings.ray_resampling`); off by default (PROBE_RAY_REPROJECTION_SCOPE_2026_11_01.md) |
@@ -39,6 +39,5 @@ the camera, the sun or the point lights restarts it. It stops at three bounces.
 
 ## What to expect
 
-Specular light still comes from the environment, unoccluded, until the probes' specular lands (the
-proposal's S6). Indoors, where the probes' diffuse is rightly darker than IBL's, that sky reflection shows
-as a bluish sheen over cloth and stone.
+Both lobes come from the probes (the proposal's §9). A pixel no probe weighs anything for takes the
+environment's light for both, as IBL gives it.

package/src/shade/playground/probe_clipmap/index.html

@@ -99,7 +99,11 @@
             <option value="None" selected>None</option>
             <option value="BrickClipmap">Brick clipmap — what the rays see</option>
             <option value="MeshSDF">Mesh SDF — the geometry caches</option>
-            <option value="MeshCards">Mesh cards — the hits' albedo</option>
+            <option value="MeshSurfaces">Mesh surfaces — each mesh's surface cache</option>
+            <option value="IndirectDiffuse">Indirect diffuse — the probes' irradiance / π, before the material</option>
+            <option value="IndirectSpecular">Indirect specular — the probes' radiance, before the material</option>
+            <option value="BrickMaterial">Brick material — the probes' hits' albedo</option>
+            <option value="BrickMetalRough">Brick material — the probes' hits' metal (R) and rough (G)</option>
         </select>
     </label>
 
@@ -153,18 +157,6 @@
         frame-time knob; this page starts higher so Sponza is whole in seconds, not minutes.
     </p>
 
-    <label>
-        <span>Card capture</span>
-        <select id="card_capture_mode">
-            <option value="Raster" selected>Raster — the material's own pass</option>
-            <option value="Trace">Trace — a ray a texel</option>
-        </select>
-    </label>
-    <p class="note">
-        How the cards take their albedo. A change captures every card set again; the Mesh cards view
-        shows what they hold.
-    </p>
-
     <hr>
 
     <div id="status"></div>

package/src/shade/playground/probe_clipmap/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AA0FA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CA0SzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AAyFA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAsSzB"}

package/src/shade/playground/probe_clipmap/main.js

@@ -11,7 +11,6 @@ import { camera_frame_sphere } from "../../renderer/camera/camera_frame_sphere.j
 import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
 import { create_frame_loop } from "../../renderer/create_frame_loop.js";
-import { MeshCardCaptureMode } from "../../renderer/geometry/sdf/cards/MeshCardCaptureMode.js";
 import { ProbeClipmapDebugView } from "../../renderer/global_illumination/probe_clipmap/debug/ProbeClipmapDebugView.js";
 import { make_sunlight } from "../../renderer/light/make_sunlight.js";
 import { PointLight } from "../../renderer/light/model/PointLight.js";
@@ -242,10 +241,6 @@ export async function start() {
         renderer.probe_clipmap.debug_view = ProbeClipmapDebugView[event.target.value];
     });
 
-    element('card_capture_mode').addEventListener('change', event => {
-        renderer.probe_clipmap.card_capture_mode = MeshCardCaptureMode[event.target.value];
-    });
-
     const taa_toggle = element('taa');
     const path_tracing_toggle = element('path_tracing');
 

package/src/shade/playground/probe_clipmap_box/README.md

@@ -34,7 +34,7 @@ then open <http://localhost:5173/src/shade/playground/probe_clipmap_box/index.ht
 | Sun (1, 2, 3) | through the hole onto the red wall or the green wall, from 45°, or straight down onto the floor |
 | Hole open (H) | closed, a lid of the hole's size sits flush in the ceiling; it is placed into the scene and taken out again, so the bricks the rays march are rebuilt as a level's would be |
 | Indirect light | the probe clipmap, or IBL to compare against |
-| Debug view | the brick clipmap as the rays see it; the geometry caches' mesh SDF; the hits' albedo from the cards |
+| Debug view | the brick clipmap as the rays see it; the geometry caches' mesh SDF; the hits' albedo from the meshes' surface caches |
 | Restart GI (K) | gives the clipmaps back and builds them again from nothing, the geometry caches kept: a cold start without a reload |
 | Path tracer (P) | the accumulating path tracer, three bounces, for context; TAA is off while it is on |
 | TAA | the resolve the probe pick's noise is meant for |

package/src/shade/playground/probe_clipmap_box/index.html

@@ -127,7 +127,7 @@
             <option value="None" selected>None</option>
             <option value="BrickClipmap">Brick clipmap — what the rays see</option>
             <option value="MeshSDF">Mesh SDF — the geometry caches</option>
-            <option value="MeshCards">Mesh cards — the hits' albedo</option>
+            <option value="MeshSurfaces">Mesh surfaces — each mesh's surface cache</option>
         </select>
     </label>
 

package/src/shade/playground/ssr_reprojection/SpatialFilterProbe.js

@@ -16,7 +16,7 @@ const shader = new ImageShader({
         body:CodeChunk.from(/* language=WGSL */ `
 @fragment fn main(@builtin(position) coord:vec4f) -> @location(0) vec4f {
     let p = vec2i(coord.xy);
-    if (decode_g_buffer_normal(textureLoad(tNormal,p,0).xy).y < 0.99) { return vec4f(-1.0); }
+    if (decode_g_buffer_normal(textureLoad(tNormal,p,0).x).y < 0.99) { return vec4f(-1.0); }
     let a = textureLoad(tBefore,p,0);
     let b = textureLoad(tAfter,p,0);
     let difference = abs(a.rgb-b.rgb);