@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js

@@ -25,18 +25,17 @@ import {
     BRICK_ATLAS_TEXTURE_RESOURCE,
     BRICK_LEVELS_RESOURCE,
     BRICK_MAP_TEXTURE_RESOURCE,
-    BRICK_OBJECTS_RESOURCE,
     BRICK_OCCUPANCY_TEXTURE_RESOURCE,
     BRICK_SAMPLER_RESOURCE,
-    chunk_brick_clipmap_object,
     chunk_brick_clipmap_trace
 } from "../brick/chunk_brick_clipmap_trace.js";
 import {
     chunk_probe_clipmap,
     chunk_probe_clipmap_guide,
     chunk_probe_clipmap_ray_layout,
-    chunk_probe_clipmap_ray_noise,
+    chunk_probe_clipmap_ray_jitter,
     chunk_probe_clipmap_ray_origin,
+    chunk_probe_clipmap_ray_visit,
     chunk_probe_clipmap_ray_texel,
     PROBE_GUIDE_READ_RESOURCE,
     PROBE_ORIGINS_READ_RESOURCE,
@@ -85,8 +84,7 @@ resources.createGroup()
     .add(BRICK_MAP_TEXTURE_RESOURCE)
     .add(BRICK_OCCUPANCY_TEXTURE_RESOURCE)
     .add(BRICK_ATLAS_TEXTURE_RESOURCE)
-    .add(BRICK_SAMPLER_RESOURCE)
-    .add(BRICK_OBJECTS_RESOURCE);
+    .add(BRICK_SAMPLER_RESOURCE);
 
 /**
  * Trace (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.6): a thread a ray of the frame's updates, dispatched
@@ -98,9 +96,10 @@ resources.createGroup()
  *   or a spread subset below R = n_r². On a guided one, the walk position whose rays the ray is among
  *   in the probe's guide (`chunk_probe_clipmap_guide`), found by bisecting the first rays. A texel's rays
  *   then follow one another, in the walk's order.
- * - **Direction**: the texel's octahedral square, jittered by white noise of the probe's slot, its update
- *   count and the ray's place in the update (`probe_clipmap_ray_noise`, `PROBE_RAY_NOISE_JITTER`), on
- *   uniform and guided updates alike. Nothing stratifies the jitter inside a texel.
+ * - **Direction**: the texel's octahedral square, jittered by a point of one of the texel's Sobol sequences
+ *   (`probe_clipmap_ray_jitter`): the sequence of the ray's round among the texel's rays and of the kind of
+ *   update, at the count of the probe's earlier updates of that kind (`probe_clipmap_ray_visit`). A texel's
+ *   rays of a round and kind are stratified inside it over the updates of that kind it takes them on.
  * - **Origin**: a point of a small ball around the probe where relocation left it, `probe_origins`, one a
  *   ray (`probe_clipmap_ray_origin`); t_min one voxel of the brick cascade there.
  * - **Direct light**: a hit off a front face takes E_dir = Σ colour·max(0, n·l)·visibility over the
@@ -114,8 +113,8 @@ resources.createGroup()
  *   surface turned from a light traces no ray toward it, since the light gives it nothing.
  * - **Back face**: a hit whose field's gradient is along the ray, so it came from inside a solid.
  *
- * Writes the ray's `PROBE_RAY_STRUCT`, with the `meshes` row of the hit's surface and E_dir as its
- * light, which shade turns into the ray's radiance, and its probe's place in the list in its flags.
+ * Writes the ray's `PROBE_RAY_STRUCT`, with E_dir as its light, which shade turns into the ray's
+ * radiance, and its probe's place in the list in its flags.
  *
  * @type {ComputeShader}
  */
@@ -154,7 +153,7 @@ fn main(
     let k = probe_clipmap_ray_probe(ray);
 
     if (k >= probe_ray_sums.count) {
-        probe_rays[ray].row = 0u;
+        probe_rays[ray].albedo = 0u;
         probe_rays[ray].flags = PROBE_RAY_NONE;
 
         return;
@@ -173,16 +172,23 @@ fn main(
     let updates = probe_state_updates(state.x);
 
     var texel: u32;
+    // the ray's place among its texel's rays in the update, as accumulation counts them
+    var round: u32;
 
     if (probe_clipmap_guided(state.x, settings.uniform_period, settings.rays_per_probe, texels)) {
         let base = k * probe_clipmap_guide_words(n);
+        let position = probe_trace_guided_position(base, i, texels);
 
-        texel = probe_clipmap_guide_texel(probe_trace_guided_position(base, i, texels), updates, n);
+        texel = probe_clipmap_guide_texel(position, updates, n);
+        round = i - probe_guide[base + position];
     } else {
         texel = probe_clipmap_ray_texel(i, updates, rays, texels);
+        // every texel once, then again: below R = n_r² the update's rays are all its first
+        round = i / texels;
     }
 
-    let jitter = probe_clipmap_ray_noise(slot, updates, i, PROBE_RAY_NOISE_JITTER);
+    let visit = probe_clipmap_ray_visit(state.x, round, rays, texels, settings.uniform_period, settings.rays_per_probe);
+    let jitter = probe_clipmap_ray_jitter(slot, texel, visit.x, visit.y);
     let direction = uv_octahedral_unit_decode((vec2<f32>(f32(texel % n), f32(texel / n)) + jitter) / f32(n));
     let packed = pack2x16unorm(uv_octahedral_unit_encode(direction));
 
@@ -238,7 +244,7 @@ fn main(
     probe_rays[ray].t = hit.t;
     probe_rays[ray].direction = packed;
     probe_rays[ray].normal = select(0u, pack2x16unorm(uv_octahedral_unit_encode(hit.normal)), is_hit);
-    probe_rays[ray].row = brick_clipmap_object(hit);
+    probe_rays[ray].albedo = 0u;
     probe_rays[ray].flags = hit.kind | select(0u, PROBE_RAY_BACK_FACE, back_face) | (select(0u, hit.cascade, is_hit) << PROBE_RAY_CASCADE_SHIFT) | (k << PROBE_RAY_PROBE_SHIFT);
     probe_rays[ray].light = rgbe9995_encode(direct);
 }
@@ -246,14 +252,14 @@ fn main(
             chunk_probe_clipmap,
             chunk_probe_clipmap_ray_layout,
             chunk_probe_clipmap_ray_texel,
-            chunk_probe_clipmap_ray_noise,
+            chunk_probe_clipmap_ray_jitter,
+            chunk_probe_clipmap_ray_visit,
             chunk_probe_clipmap_ray_origin,
             chunk_probe_clipmap_guide,
             chunk_folded_workgroup_index,
             chunk_uv_octahedral_unit_decode,
             chunk_uv_octahedral_unit_encode,
             chunk_brick_clipmap_trace,
-            chunk_brick_clipmap_object,
             chunk_cone_sample_direction,
             chunk_pcg3d,
             chunk_hash_to_float01,

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,kCAFU,YAAY,CAUE;AAexB;;;;;;;;;;;;;GAaG;AACH,wCAFU,aAAa,CAqCpB;6BAtF0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,kCAFU,YAAY,CAcE;AAexB;;;;;;;;;;;;;GAaG;AACH,wCAFU,aAAa,CAqCpB;6BA1F0B,sCAAsC;8BAHrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js

@@ -7,7 +7,7 @@ import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_s
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { f32, u32, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 import {
@@ -30,6 +30,10 @@ export const PROBE_WANT_SETTINGS = WebGPUStruct.from({
     frame: u32,
     /** what the wanted list holds at most: every key, or fewer where the wants cannot want more */
     wanted_capacity: u32,
+    /** where the windows were placed around, world metres: the selection boxes' centre, as the pick reads it */
+    anchor: vec3f,
+    /** a selection box's half side, in its cascade's cells, as the pick reads it */
+    select_half: f32,
 }, "ProbeWantSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -79,11 +83,11 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
 
     let uv = (vec2<f32>(pixel) + 0.5) / vec2<f32>(size);
     let position = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
-    let normal = decode_g_buffer_normal(textureLoad(gBufferNormals, pixel, 0).xy);
+    let normal = decode_g_buffer_normal(textureLoad(gBufferNormals, pixel, 0).x);
     let view_direction = normalize(mat4_extract_position(camera.transform) - position);
     let bias_direction = mix(normal, view_direction, ${PROBE_RECEIVER_BIAS_VIEW});
 
-    probe_clipmap_want(on_screen && !is_background(depth), position, bias_direction, settings.cascade_count, settings.resolution, settings.wanted_capacity);
+    probe_clipmap_want(on_screen && !is_background(depth), position, bias_direction, settings.cascade_count, settings.resolution, settings.anchor, settings.select_half, settings.wanted_capacity);
 }
 `, [
             chunk_probe_clipmap,

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want_hits.d.ts

@@ -4,8 +4,8 @@
  * `PROBE_DISPATCH_RAYS` of that clipmap, before its frame's lifetime writes them over. The points go on this
  * clipmap's wanted list, through its levels.
  *
- * A front-face hit whose `row` the light passes left non-zero wants the cages its pick reads in this clipmap:
- * the bounce pass clears the row of a hit whose first set held probes, so a hit wants only where that set
+ * A front-face hit whose `albedo` the light passes left non-zero wants the cages its pick reads in this clipmap:
+ * the bounce pass clears the albedo of a hit whose first set held probes, so a hit wants only where that set
  * had none, and this clipmap's probes are its fallback (`shader_probe_clipmap_bounce`). So a probe a hit needs
  * is admitted where the first set has none, and kept while hits read it. Until its first update a NEW probe
  * weighs nothing and the hit takes no bounce: light is lost for a frame or two, never invented.

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want_hits.js

@@ -37,8 +37,8 @@ resources.createGroup()
  * `PROBE_DISPATCH_RAYS` of that clipmap, before its frame's lifetime writes them over. The points go on this
  * clipmap's wanted list, through its levels.
  *
- * A front-face hit whose `row` the light passes left non-zero wants the cages its pick reads in this clipmap:
- * the bounce pass clears the row of a hit whose first set held probes, so a hit wants only where that set
+ * A front-face hit whose `albedo` the light passes left non-zero wants the cages its pick reads in this clipmap:
+ * the bounce pass clears the albedo of a hit whose first set held probes, so a hit wants only where that set
  * had none, and this clipmap's probes are its fallback (`shader_probe_clipmap_bounce`). So a probe a hit needs
  * is admitted where the first set has none, and kept while hits read it. Until its first update a NEW probe
  * weighs nothing and the hit takes no bounce: light is lost for a frame or two, never invented.
@@ -75,10 +75,10 @@ fn main(
         let k = record.flags >> PROBE_RAY_PROBE_SHIFT;
         let slot = probe_trace.elements[k];
 
-        // shade left a front-face hit's albedo in its row and zero in any other ray's, and the bounce pass
-        // cleared the row of a hit its first set served: a ray that takes no bounce, a black hit's among them,
+        // shade left a front-face hit's albedo and zero in any other ray's, and the bounce pass cleared the
+        // albedo of a hit its first set served: a ray that takes no bounce, a black hit's among them,
         // or that had its probes, wants nothing
-        wants = record.row != 0u;
+        wants = record.albedo != 0u;
 
         let direction = uv_octahedral_unit_decode(unpack2x16unorm(record.direction));
         let normal = uv_octahedral_unit_decode(unpack2x16unorm(record.normal));
@@ -88,7 +88,7 @@ fn main(
         bias_direction = mix(normal, -direction, ${PROBE_RECEIVER_BIAS_VIEW});
     }
 
-    probe_clipmap_want(wants, position, bias_direction, settings.cascade_count, settings.resolution, settings.wanted_capacity);
+    probe_clipmap_want(wants, position, bias_direction, settings.cascade_count, settings.resolution, settings.anchor, settings.select_half, settings.wanted_capacity);
 }
 `, [
             chunk_probe_clipmap,

package/src/shade/renderer/global_illumination/shader_resolve_indirect_lighting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_resolve_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/global_illumination/shader_resolve_indirect_lighting.js"],"names":[],"mappings":"AAkHA,2DAyBE;4BA9H0B,0BAA0B"}
+{"version":3,"file":"shader_resolve_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/global_illumination/shader_resolve_indirect_lighting.js"],"names":[],"mappings":"AAoHA,2DAyBE;4BA/H0B,0BAA0B"}

package/src/shade/renderer/global_illumination/shader_resolve_indirect_lighting.js

@@ -7,6 +7,7 @@ import { chunk_project_position_from_depth } from "../shader/chunk/camera/chunk_
 import { chunk_mat4_extract_position } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_decode_g_buffer_normal } from "../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
 import { chunk_compute_indirect_specular } from "../shader/chunk/material/chunk_compute_indirect_specular.js";
+import { chunk_decode_g_buffer_albedo } from "../shader/chunk/material/chunk_decode_g_buffer_albedo.js";
 import { chunk_decode_g_buffer_metalness } from "../shader/chunk/material/chunk_decode_g_buffer_metalness.js";
 import { chunk_decode_g_buffer_roughness } from "../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
 import { chunk_metalness_to_specular_color } from "../shader/chunk/material/chunk_metalness_to_specular_color.js";
@@ -47,7 +48,7 @@ fn main(
 
     let albedo_ao_sample = textureLoad( tGBufferAlbedo, coord_i, 0 );
 
-    let albedo = albedo_ao_sample.rgb;
+    let albedo = decode_g_buffer_albedo(albedo_ao_sample.rgb);
     let occlusion = albedo_ao_sample.a;
 
     let f_metalness = decode_g_buffer_metalness(texel_pbr);
@@ -68,8 +69,8 @@ fn main(
 
     let view_direction = normalize(view_position - position_ws);
 
-    let shading_normal = decode_g_buffer_normal(textureLoad(tGBufferNormals, coord_i, 0).xy);
-    let bent_normal    = decode_g_buffer_normal(textureLoad(tBentNormals, coord_i, 0).xy);
+    let shading_normal = decode_g_buffer_normal(textureLoad(tGBufferNormals, coord_i, 0).x);
+    let bent_normal    = decode_g_buffer_normal(textureLoad(tBentNormals, coord_i, 0).x);
 
     // tIndirectDiffuse contract: AO already baked in by the source pass.
     // Do not multiply the diffuse term by occlusion again here.
@@ -104,6 +105,7 @@ fn main(
         chunk_decode_g_buffer_normal,
         chunk_mat4_extract_position,
         chunk_project_position_from_depth,
+        chunk_decode_g_buffer_albedo,
         chunk_decode_g_buffer_metalness,
         chunk_decode_g_buffer_roughness,
         chunk_metalness_to_specular_color,

package/src/shade/renderer/global_illumination/sharc/shader/debug/shader_colored_hash.js

@@ -41,7 +41,7 @@ fn main(
                
     let g_buffer_sample_normal = textureLoad(gBufferNormal, i_coord, 0);
     
-    let shading_normal = decode_g_buffer_normal(g_buffer_sample_normal.xy);
+    let shading_normal = decode_g_buffer_normal(g_buffer_sample_normal.x);
     
     if(texel_depth == ${DEPTH_BACKGROUND_VALUE}){
         // outside of the scene, sample sky

package/src/shade/renderer/global_illumination/sharc/shader/debug/shader_sharc_debug_radiance.js

@@ -57,7 +57,7 @@ fn main(
     
     let g_buffer_sample_normal = textureLoad(gBufferNormals, i_coord, 0);
     
-    let shading_normal = decode_g_buffer_normal(g_buffer_sample_normal.xy);
+    let shading_normal = decode_g_buffer_normal(g_buffer_sample_normal.x);
     
     
     let entryIndex = hash_map_find_entry(

package/src/shade/renderer/global_illumination/sharc/shader/shader_sharc_update.js

@@ -84,7 +84,7 @@ fn main(@builtin(global_invocation_id) global_id : vec3<u32>){
                
     let g_buffer_sample_normal = textureLoad(gBufferNormals, i_coord, 0);
     
-    let shading_normal = decode_g_buffer_normal(g_buffer_sample_normal.xy);
+    let shading_normal = decode_g_buffer_normal(g_buffer_sample_normal.x);
     
     let view_position = mat4_extract_position(camera.transform);
     let view_direction = normalize(view_position - position_ws);

package/src/shade/renderer/gpu_primitive/hash_table/chunk_generate_next_linear_congruential_index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The step of a hash table's probe sequence: `(5 index + 1) mod 2^K`, which visits every record of a
+ * table of 2^K records once before it repeats. The WGSL twin of
+ * `core/collection/map/generate_next_linear_congruential_index.js`.
+ *
+ * ```wgsl
+ * fn generate_next_linear_congruential_index(index: u32, mask: u32) -> u32   // mask: 2^K - 1
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_generate_next_linear_congruential_index: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_generate_next_linear_congruential_index.d.ts.map

package/src/shade/renderer/gpu_primitive/hash_table/chunk_generate_next_linear_congruential_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_generate_next_linear_congruential_index.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/chunk_generate_next_linear_congruential_index.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,4DAFU,SAAS,CAUhB;0BArBuB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/hash_table/chunk_generate_next_linear_congruential_index.js

@@ -0,0 +1,22 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The step of a hash table's probe sequence: `(5 index + 1) mod 2^K`, which visits every record of a
+ * table of 2^K records once before it repeats. The WGSL twin of
+ * `core/collection/map/generate_next_linear_congruential_index.js`.
+ *
+ * ```wgsl
+ * fn generate_next_linear_congruential_index(index: u32, mask: u32) -> u32   // mask: 2^K - 1
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_generate_next_linear_congruential_index = CodeChunk.from(
+    //language=WGSL
+    `
+fn generate_next_linear_congruential_index(index: u32, mask: u32) -> u32 {
+    let index5 = index * 5u;
+
+    return (index5 + 1u) & mask;
+}
+`);

package/src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_atomic.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The encoded key of a record removed from a table the device keeps ({@link chunk_hash_table_atomic}):
+ * a probe passes over it as over another key's record, and an insert may take its place. No key
+ * encodes to it, keys staying below `0xFFFFFFFE`.
+ * @type {number}
+ */
+export const HASH_TABLE_REMOVED: number;
+/**
+ * The table `cpu_build_hash_table` lays out (`[element_count, table_size]`, then `table_size` records
+ * of `(key + 1, value)`, an empty record 0) kept on the device: inserted into and removed from by
+ * atomics, on `hash_table_get`'s probe sequence and limit. A key may hold several records, which find
+ * visits in turn; the caller tells them apart by what their values name. `element_count` counts the
+ * records held.
+ *
+ * ```wgsl
+ * fn hash_table_atomic_start(table, offset: u32, key: u32) -> vec2<u32>                           // a cursor at the key's first record
+ * fn hash_table_atomic_find(table, offset: u32, key: u32, cursor: ptr<function, vec2<u32>>) -> u32  // the key's next record, or HASH_TABLE_MISS
+ * fn hash_table_atomic_value(table, record: u32) -> u32
+ * fn hash_table_atomic_insert(table, offset: u32, key: u32, value: u32) -> bool                    // false: no record free within the probe limit
+ * fn hash_table_atomic_remove(table, offset: u32, record: u32)
+ * ```
+ *
+ * `table` is a `ptr<storage, array<atomic<u32>>, read_write>`, and a record is named by the word it
+ * starts at. Insert claims the first empty or removed record of the key's sequence by
+ * compare-exchange on its key and stores the value after it, so a find racing that insert in one
+ * dispatch may read the value before it lands: a caller whose inserts share a dispatch with its finds
+ * checks what a value names before trusting it. Inserts and removes of different records may share a
+ * dispatch. A find ends at the sequence's first empty record or at the probe limit.
+ *
+ * A table holds at least `HASH_TABLE_PROBE_LIMIT` records, a power of two, so that the probes of a
+ * key's sequence meet no record twice.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_hash_table_atomic: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_hash_table_atomic.d.ts.map

package/src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_atomic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_hash_table_atomic.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_atomic.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,iCAFU,MAAM,CAE6B;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,sCAFU,SAAS,CAmFZ;0BAxHmB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_atomic.js

@@ -0,0 +1,122 @@
+import { chunk_hash_lowbias32 } from "../../shader/chunk/random/chunk_hash_lowbias32.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_generate_next_linear_congruential_index } from "./chunk_generate_next_linear_congruential_index.js";
+import { HASH_TABLE_MISS, HASH_TABLE_PROBE_LIMIT } from "./cpu_build_hash_table.js";
+
+/**
+ * The encoded key of a record removed from a table the device keeps ({@link chunk_hash_table_atomic}):
+ * a probe passes over it as over another key's record, and an insert may take its place. No key
+ * encodes to it, keys staying below `0xFFFFFFFE`.
+ * @type {number}
+ */
+export const HASH_TABLE_REMOVED = 0xFFFFFFFF;
+
+/**
+ * The table `cpu_build_hash_table` lays out (`[element_count, table_size]`, then `table_size` records
+ * of `(key + 1, value)`, an empty record 0) kept on the device: inserted into and removed from by
+ * atomics, on `hash_table_get`'s probe sequence and limit. A key may hold several records, which find
+ * visits in turn; the caller tells them apart by what their values name. `element_count` counts the
+ * records held.
+ *
+ * ```wgsl
+ * fn hash_table_atomic_start(table, offset: u32, key: u32) -> vec2<u32>                           // a cursor at the key's first record
+ * fn hash_table_atomic_find(table, offset: u32, key: u32, cursor: ptr<function, vec2<u32>>) -> u32  // the key's next record, or HASH_TABLE_MISS
+ * fn hash_table_atomic_value(table, record: u32) -> u32
+ * fn hash_table_atomic_insert(table, offset: u32, key: u32, value: u32) -> bool                    // false: no record free within the probe limit
+ * fn hash_table_atomic_remove(table, offset: u32, record: u32)
+ * ```
+ *
+ * `table` is a `ptr<storage, array<atomic<u32>>, read_write>`, and a record is named by the word it
+ * starts at. Insert claims the first empty or removed record of the key's sequence by
+ * compare-exchange on its key and stores the value after it, so a find racing that insert in one
+ * dispatch may read the value before it lands: a caller whose inserts share a dispatch with its finds
+ * checks what a value names before trusting it. Inserts and removes of different records may share a
+ * dispatch. A find ends at the sequence's first empty record or at the probe limit.
+ *
+ * A table holds at least `HASH_TABLE_PROBE_LIMIT` records, a power of two, so that the probes of a
+ * key's sequence meet no record twice.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_hash_table_atomic = CodeChunk.from(
+    //language=WGSL
+    `
+const HASH_TABLE_MISS = ${HASH_TABLE_MISS}u;
+const HASH_TABLE_REMOVED = ${HASH_TABLE_REMOVED}u;
+const HASH_TABLE_PROBE_LIMIT = ${HASH_TABLE_PROBE_LIMIT}u;
+
+fn hash_table_atomic_start(table: ptr<storage, array<atomic<u32>>, read_write>, offset: u32, key: u32) -> vec2<u32> {
+    let mask = atomicLoad(&(*table)[offset + 1u]) - 1u;
+
+    // the record index, then the probes taken
+    return vec2<u32>(hash_lowbias32(key) & mask, 0u);
+}
+
+fn hash_table_atomic_find(table: ptr<storage, array<atomic<u32>>, read_write>, offset: u32, key: u32, cursor: ptr<function, vec2<u32>>) -> u32 {
+    let mask = atomicLoad(&(*table)[offset + 1u]) - 1u;
+    let encoded = key + 1u;
+
+    while ((*cursor).y < HASH_TABLE_PROBE_LIMIT) {
+        let record = offset + 2u + 2u * (*cursor).x;
+        let stored = atomicLoad(&(*table)[record]);
+
+        *cursor = vec2<u32>(generate_next_linear_congruential_index((*cursor).x, mask), (*cursor).y + 1u);
+
+        if (stored == 0u) {
+            // the key's sequence ends at its first empty record
+            (*cursor).y = HASH_TABLE_PROBE_LIMIT;
+
+            return HASH_TABLE_MISS;
+        }
+
+        if (stored == encoded) {
+            return record;
+        }
+    }
+
+    return HASH_TABLE_MISS;
+}
+
+fn hash_table_atomic_value(table: ptr<storage, array<atomic<u32>>, read_write>, record: u32) -> u32 {
+    return atomicLoad(&(*table)[record + 1u]);
+}
+
+fn hash_table_atomic_insert(table: ptr<storage, array<atomic<u32>>, read_write>, offset: u32, key: u32, value: u32) -> bool {
+    let mask = atomicLoad(&(*table)[offset + 1u]) - 1u;
+
+    var index = hash_lowbias32(key) & mask;
+
+    for (var probe = 0u; probe < HASH_TABLE_PROBE_LIMIT; probe++) {
+        let record = offset + 2u + 2u * index;
+        let stored = atomicLoad(&(*table)[record]);
+
+        if (stored == 0u || stored == HASH_TABLE_REMOVED) {
+            let claim = atomicCompareExchangeWeak(&(*table)[record], stored, key + 1u);
+
+            if (claim.exchanged) {
+                atomicStore(&(*table)[record + 1u], value);
+                atomicAdd(&(*table)[offset], 1u);
+
+                return true;
+            }
+
+            if (claim.old_value == stored) {
+                // a weak exchange may fail on a record that still holds what it read: the same record again
+                continue;
+            }
+        }
+
+        index = generate_next_linear_congruential_index(index, mask);
+    }
+
+    return false;
+}
+
+fn hash_table_atomic_remove(table: ptr<storage, array<atomic<u32>>, read_write>, offset: u32, record: u32) {
+    atomicStore(&(*table)[record], HASH_TABLE_REMOVED);
+    atomicSub(&(*table)[offset], 1u);
+}
+`, [
+        chunk_generate_next_linear_congruential_index,
+        chunk_hash_lowbias32,
+    ]);

package/src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_get.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_hash_table_get.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_get.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,mCAFU,SAAS,CAkDlB;0BAjEyB,oCAAoC"}
+{"version":3,"file":"chunk_hash_table_get.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_get.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,mCAFU,SAAS,CAkDlB;0BAvDyB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_get.js

@@ -1,16 +1,6 @@
 import { chunk_hash_lowbias32 } from "../../shader/chunk/random/chunk_hash_lowbias32.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-const chunk_generate_next_linear_congruential_index = CodeChunk.from(
-    //language=WGSL
-    `
-fn generate_next_linear_congruential_index(index:u32, mask: u32) -> u32{
-    let index5 = index * 5;
-
-    return (index5 + 1) & mask;
-}
-    `
-)
+import { chunk_generate_next_linear_congruential_index } from "./chunk_generate_next_linear_congruential_index.js";
 
 /**
  * @see cpu_build_hash_table

package/src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.d.ts

@@ -40,6 +40,14 @@ export function cpu_hash_table_word_count(input_size: number): number;
  * @see cpu_build_hash_table to build at a given size
  */
 export function cpu_hash_table_create(table: Uint32Array, inputs: number[], input_size: number): boolean;
+/**
+ * Maximum number of slots visited per operation.
+ * Must match the WGSL twins ({@link chunk_hash_table_get}, `chunk_hash_table_atomic`): a lookup probes
+ * at most this many slots, so an insert that cannot place a record within the limit must report it —
+ * otherwise it would create an entry that lookups can never reach.
+ * @type {number}
+ */
+export const HASH_TABLE_PROBE_LIMIT: number;
 /**
  * Sentinel returned on lookup miss.
  * Must match the WGSL twin ({@link chunk_hash_table_get}).

package/src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cpu_build_hash_table.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.js"],"names":[],"mappings":"AAoEA;;;;;;GAMG;AACH,0CALW,WAAW,UACX,MAAM,OACN,MAAM,GACJ,MAAM,CAsClB;AAED;;;;;;;;;GASG;AACH,6CARW,WAAW,iBACX,MAAM,cACN,MAAM,UACN,MAAM,EAAE,cACR,MAAM,GACJ,OAAO,CA2BnB;AAWD;;;;;GAKG;AACH,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;GAcG;AACH,6CARW,WAAW,UACX,MAAM,EAAE,cACR,MAAM,GACJ,OAAO,CAkBnB;AAnLD;;;;GAIG;AACH,8BAFU,MAAM,CAE0B"}
+{"version":3,"file":"cpu_build_hash_table.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.js"],"names":[],"mappings":"AAsEA;;;;;;GAMG;AACH,0CALW,WAAW,UACX,MAAM,OACN,MAAM,GACJ,MAAM,CAsClB;AAED;;;;;;;;;GASG;AACH,6CARW,WAAW,iBACX,MAAM,cACN,MAAM,UACN,MAAM,EAAE,cACR,MAAM,GACJ,OAAO,CA2BnB;AAWD;;;;;GAKG;AACH,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;GAcG;AACH,6CARW,WAAW,UACX,MAAM,EAAE,cACR,MAAM,GACJ,OAAO,CAkBnB;AA9LD;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB;AAIzC;;;;GAIG;AACH,8BAFU,MAAM,CAE0B"}

package/src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.js

@@ -8,12 +8,14 @@ import { isPowerOfTwo } from "../../../../core/math/isPowerOfTwo.js";
 
 /**
  * Maximum number of slots visited per operation.
- * Must match the WGSL twin ({@link chunk_hash_table_get}): a lookup probes at most this many slots,
- * so an insert that cannot place a record within the limit must report it — otherwise it would
- * create an entry that lookups can never reach.
+ * Must match the WGSL twins ({@link chunk_hash_table_get}, `chunk_hash_table_atomic`): a lookup probes
+ * at most this many slots, so an insert that cannot place a record within the limit must report it —
+ * otherwise it would create an entry that lookups can never reach.
  * @type {number}
  */
-const PROBE_LIMIT = 32;
+export const HASH_TABLE_PROBE_LIMIT = 32;
+
+const PROBE_LIMIT = HASH_TABLE_PROBE_LIMIT;
 
 /**
  * Sentinel returned on lookup miss.

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#306@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#308@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/material/GPUMaterialManager.d.ts

@@ -36,18 +36,19 @@ export class GPUMaterialManager {
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {GPUViewContext} options.view
-     * @param {number} options.texture_viz_mesh
-     * @param {number} options.texture_viz_triangle
-     * @param {number} options.texture_normal the normal target to write, `rgba16uint` at the view's
-     *   resolution. The caller owns it so that it outlives the frame: reprojection reads last frame's.
+     * @param {number} options.texture_visibility the visibility buffer
+     * @param {number} options.visible_meshlets the frame's visible-meshlet table, which resolves it
+     * @param {number} options.texture_pbr the PBR target to write, `G_BUFFER_COLOR_TARGETS[0].format` at
+     *   the view's resolution. The caller owns it so that it outlives the frame: reprojection reads last
+     *   frame's face normal from it.
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}} updated g-buffer
      */
-    graph_viz_render({ graph, view, texture_viz_mesh, texture_viz_triangle, texture_normal, }: {
+    graph_viz_render({ graph, view, texture_visibility, visible_meshlets, texture_pbr, }: {
         graph: FrameGraph;
         view: GPUViewContext;
-        texture_viz_mesh: number;
-        texture_viz_triangle: number;
-        texture_normal: number;
+        texture_visibility: number;
+        visible_meshlets: number;
+        texture_pbr: number;
     }): {
         g_pbr: number;
         g_normal: number;
@@ -121,12 +122,24 @@ export class GPUMaterialManager {
     /**
      * The contexts the G-buffer pass draws for a scene's drawn materials: every one that is not
      * transparent and has a context, grouped by template, in the order {@link graph_viz_render} draws
-     * them. The array is kept and rebuilt in place — {@link gbuffer_contexts_version} says when.
+     * them. A material's index here is its place in the pass. The array is replaced, never
+     * rewritten, when the list changes — {@link gbuffer_contexts_version} says when — so one held
+     * across a change still names the places it was read with.
      *
      * @param {ShadeMaterial[]} drawn a scene's {@link GPUSceneContext#drawn_materials}
      * @returns {GPUMaterialContext[]}
      */
     gbuffer_contexts(drawn: ShadeMaterial[]): GPUMaterialContext[];
+    /**
+     * Each of {@link gbuffer_contexts} at its place there, keyed by material id: a
+     * {@link cpu_hash_table_create} table, for a shader that starts from the material id of a mesh
+     * (read with `hash_table_get`, a miss for a material the pass does not draw). Replaced along with
+     * the list, so it always matches the array {@link gbuffer_contexts} returns at the same version.
+     *
+     * @param {ShadeMaterial[]} drawn a scene's {@link GPUSceneContext#drawn_materials}
+     * @returns {Uint32Array}
+     */
+    gbuffer_slot_table(drawn: ShadeMaterial[]): Uint32Array;
     /**
      * Moves whenever {@link gbuffer_contexts} may answer differently for the same drawn set.
      *

package/src/shade/renderer/material/GPUMaterialManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA8QA;IA4FI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IAlJD;;;;;OAKG;IACH,wBAAkC;IAOlC;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IA0LD;;;;;;;;;;OAUG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,cAAc,EAA9B,MAAM;QAEJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAmNnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;;OAOG;IACH,wBAHW,aAAa,EAAE,GACb,kBAAkB,EAAE,CAIhC;IAED;;;;OAIG;IACH,uCAEC;IAED;;;;OAIG;IACH,oCAEC;IA4ED;;;OAGG;IACH,YAFW,sBAAsB,QAmChC;;CAEJ;8BA5+BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCArBG,8CAA8C;oCAwBxB,mCAAmC"}
+{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AAiUA;IA4FI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IAlJD;;;;;OAKG;IACH,wBAAkC;IAOlC;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IA+LD;;;;;;;;;;;OAWG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,kBAAkB,EAAlC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACU,WAAW,EAA3B,MAAM;QAGJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA0OnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;;;;OASG;IACH,wBAHW,aAAa,EAAE,GACb,kBAAkB,EAAE,CAIhC;IAED;;;;;;;;OAQG;IACH,0BAHW,aAAa,EAAE,GACb,WAAW,CAMvB;IAED;;;;OAIG;IACH,uCAEC;IAED;;;;OAIG;IACH,oCAEC;IAyED;;;OAGG;IACH,YAFW,sBAAsB,QAmChC;;CAEJ;8BApkCY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAvBzE,yBAAyB;mCA1BG,8CAA8C;oCA8BxB,mCAAmC"}