@woosh/meep-engine 3.61.3 → 3.62.0

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

@@ -11,6 +11,7 @@ import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/
 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";
@@ -61,7 +62,7 @@ fn main(
     let texel_pbr = textureLoad(tGBufferPBR, i_coord, 0);
     let albedo_ao = textureLoad(tGBufferAlbedo, i_coord, 0);
 
-    let albedo = albedo_ao.rgb;
+    let albedo = decode_g_buffer_albedo(albedo_ao.rgb);
     let occlusion = albedo_ao.a;
 
     let f_metalness = decode_g_buffer_metalness(texel_pbr);
@@ -75,8 +76,8 @@ fn main(
     let view_direction = normalize(mat4_extract_position(camera.transform) - position);
 
     // the surface's own normal picks, as want chose by it; the bent normal resolves the diffuse, as IBL's does
-    let normal = decode_g_buffer_normal(textureLoad(tNormals, i_coord, 0).xy);
-    let bent_normal = decode_g_buffer_normal(textureLoad(tBentNormals, i_coord, 0).xy);
+    let normal = decode_g_buffer_normal(textureLoad(tNormals, i_coord, 0).x);
+    let bent_normal = decode_g_buffer_normal(textureLoad(tBentNormals, i_coord, 0).x);
 
     // one pick for both lobes
     let noise = stbn_sample_vec2(vec3<u32>(i_coord, view.frame_index));
@@ -120,6 +121,7 @@ fn main(
     chunk_project_position_from_depth,
     chunk_mat4_extract_position,
     chunk_decode_g_buffer_normal,
+    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/probe_clipmap/probe/shader_probe_clipmap_want.js

@@ -83,7 +83,7 @@ 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});
 

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/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"}

package/src/shade/renderer/material/GPUMaterialManager.js

@@ -11,11 +11,16 @@ import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescr
 import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
 import { BindGroupDescriptor } from "../binding/BindGroupDescriptor.js";
 import { GPUSingleTypeTable } from "../buffer/table/single/GPUSingleTypeTable.js";
-import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
 import { G_BUFFER_ALBEDO_FORMAT } from "../gbuffer/G_BUFFER_ALBEDO_FORMAT.js";
+import { G_BUFFER_COLOR_TARGETS } from "../gbuffer/G_BUFFER_COLOR_TARGETS.js";
+import { chunk_hash_table_get } from "../gpu_primitive/hash_table/chunk_hash_table_get.js";
 import {
-    VIZ_BUFFER_INVALID_MESH_VALUE
-} from "../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+    cpu_hash_table_create,
+    cpu_hash_table_word_count
+} from "../gpu_primitive/hash_table/cpu_build_hash_table.js";
+import { graph_import_raw_buffer } from "../shader/graph/graph_import_raw_buffer.js";
+import { MESHLET_COLLECTION_STRUCT } from "../rasterize/MESHLET_COLLECTION_STRUCT.js";
+import { chunk_visibility_decode } from "../rasterize/visibility/chunk_visibility_decode.js";
 import { chunk_scene_database_access } from "../scene/chunk_scene_database_access.js";
 import {
     chunk_subgroup_bitset_or,
@@ -32,6 +37,7 @@ import {
     MATERIAL_BIND_GROUP_SCENE_DATA,
     MATERIAL_BIND_GROUP_VIZ_BUFFER
 } from "./GPUMaterialContext.js";
+import { MATERIAL_MASK_FORMAT, MATERIAL_MASK_NONE } from "./MATERIAL_MASK.js";
 import { MATERIAL_METADATA_STRUCT } from "./MATERIAL_METADATA_STRUCT.js";
 import { PIXEL_TEXTURE_ORM } from "./PIXEL_TEXTURE_ORM.js";
 import { GPUMaterialServices, MaterialGPUDefaults } from "./template/GPUMaterialServices.js";
@@ -94,11 +100,34 @@ class DrawnMaterialLists {
     gbuffer_version = -1;
 
     /**
-     * One past the highest material id in {@link gbuffer}, 0 when it is empty.
+     * Each context of {@link gbuffer} at its place in it, keyed by material id: a
+     * {@link cpu_hash_table_create} table, for shaders that start from the material id of a mesh.
      *
-     * @type {number}
+     * @type {Uint32Array}
      */
-    gbuffer_id_bound = 0;
+    gbuffer_slots = new Uint32Array(0);
+}
+
+/**
+ * @param {GPUMaterialContext[]} contexts
+ * @returns {Uint32Array} a {@link cpu_hash_table_create} table from each context's material id to its
+ *   index in `contexts`
+ */
+function build_slot_table(contexts) {
+    const count = contexts.length;
+    const ids = new Array(count);
+
+    for (let i = 0; i < count; i++) {
+        ids[i] = contexts[i].material_id;
+    }
+
+    let table = new Uint32Array(cpu_hash_table_word_count(count));
+
+    while (!cpu_hash_table_create(table, ids, count)) {
+        table = new Uint32Array(table.length * 2);
+    }
+
+    return table;
 }
 
 /**
@@ -152,7 +181,11 @@ const MATERIAL_BUFFER_BIND_GROUP_0_LAYOUT_DESCRIPTOR = BindGroupLayoutDescriptor
                 sampleType: "uint"
             }
         },
-
+        {
+            binding: 1,
+            visibility: GPUShaderStage.FRAGMENT,
+            buffer: BufferBindingLayout.readOnlyStorage
+        },
     ]
 });
 
@@ -167,22 +200,31 @@ const MATERIAL_BUFFER_BIND_GROUP_1_LAYOUT_DESCRIPTOR = BindGroupLayoutDescriptor
             binding: 1,
             visibility: GPUShaderStage.FRAGMENT,
             buffer: BufferBindingLayout.storage
+        },
+        {
+            binding: 2,
+            visibility: GPUShaderStage.FRAGMENT,
+            buffer: BufferBindingLayout.readOnlyStorage
         }
     ]
 });
 
 /**
- * The material-depth pass's fragment stage: writes the material id of each pixel as its depth, for
- * the G-buffer pass to test against, and marks in `material_seen` every material that holds a pixel.
+ * The material-depth pass's fragment stage: writes, as its depth, the place in the G-buffer pass's
+ * list of the material that holds each pixel, for the G-buffer pass to test against, and marks that
+ * place in `material_seen`. A pixel of no mesh, or of a material the list leaves out, gets the
+ * cleared value and marks nothing.
  *
  * @type {CodeChunk}
  */
 const material_depth_fragment = CodeChunk.from(
     // language=WGSL
     `
-        @group(0) @binding(0) var mesh_texture: texture_2d<u32>;
+        @group(0) @binding(0) var visibility: texture_2d<u32>;
+        @group(0) @binding(1) var<storage, read> visible_meshlets: ${MESHLET_COLLECTION_STRUCT.wgsl_ref};
         @group(1) @binding(0) var<storage, read> scene_database: array<u32>;
         @group(1) @binding(1) var<storage, read_write> material_seen: array<atomic<u32>>;
+        @group(1) @binding(2) var<storage, read> material_slots: array<u32>;
 
         struct Outputs{
             @builtin(frag_depth) depth:f32,
@@ -195,34 +237,43 @@ const material_depth_fragment = CodeChunk.from(
 
             let pixel = vec2<u32>(coord.xy);
 
-            var material = ${SUBGROUP_BITSET_OR_NONE}u;
+            // a miss in the table is the bitset's "none" as well
+            var slot = ${SUBGROUP_BITSET_OR_NONE}u;
 
             // a helper invocation past the edge of the target holds no material, so it marks nothing
-            if(all(pixel < textureDimensions(mesh_texture))){
-                let mesh_id = textureLoad(
-                    mesh_texture,
+            if(all(pixel < textureDimensions(visibility))){
+                let encoded = textureLoad(
+                    visibility,
                     pixel,
                     0
                 ).r;
 
-                if(mesh_id != ${VIZ_BUFFER_INVALID_MESH_VALUE}){
-                    material = scene_read_mesh(&scene_database, mesh_id).material;
+                if(encoded != VISIBILITY_NONE){
+                    let material = scene_read_mesh(&scene_database, visibility_decode(encoded).mesh).material;
+
+                    slot = hash_table_get(&material_slots, 0u, material);
                 }
             }
 
-            // the G-buffer pass draws only the materials marked here
-            subgroup_bitset_or(&material_seen, material);
+            // the G-buffer pass draws only the places marked here
+            subgroup_bitset_or(&material_seen, slot);
 
-            if(material == ${SUBGROUP_BITSET_OR_NONE}u){
+            if(slot == ${SUBGROUP_BITSET_OR_NONE}u){
                 return Outputs(1.0);
             }
 
             return Outputs(
-                f32(material)/16777216
+                f32(slot) / ${MATERIAL_MASK_NONE}.0
             );
         }
     `,
-    [chunk_scene_database_access, chunk_subgroup_bitset_or]
+    [
+        chunk_scene_database_access,
+        chunk_subgroup_bitset_or,
+        chunk_hash_table_get,
+        MESHLET_COLLECTION_STRUCT.declaration_chunk,
+        chunk_visibility_decode
+    ]
 );
 
 /**
@@ -255,7 +306,7 @@ const material_buffer_pipeline_descriptor = RenderPipelineDescriptor.from({
         },
     },
     depthStencil: {
-        format: 'depth32float',
+        format: MATERIAL_MASK_FORMAT,
         depthWriteEnabled: true,
         depthCompare: "always",
         // disable stencil
@@ -456,22 +507,25 @@ export class GPUMaterialManager {
      * @param {GPUViewContext} view
      * @param {GPUTextureContext} mesh_texture
      * @param {GPUTextureContext} material_depth_texture
-     * @param {GPUBufferBinding} material_seen zeroed, a bit per material id, set for each material
-     *   that holds a pixel
+     * @param {GPUBufferBinding} material_seen zeroed, a bit per place in the G-buffer pass's list, set
+     *   for each place whose material holds a pixel
+     * @param {GPUBuffer} material_slots the list's {@link gbuffer_slot_table}
      */
     #prepare_material_depth_buffer(
         encoder,
         view,
-        mesh_texture,
+        visibility,
+        visible_meshlets,
         material_depth_texture,
         material_seen,
+        material_slots,
     ) {
 
         const pass = encoder.beginRenderPass({
             label: "GPUMaterialManager/material-depth",
             colorAttachments: [],
             depthStencilAttachment: {
-                // we use very high value to indicate invalid material slot
+                // MATERIAL_MASK_NONE: no listed material
                 depthClearValue: 1,
                 view: material_depth_texture.obtainView(),
                 depthLoadOp: 'clear',
@@ -494,7 +548,8 @@ export class GPUMaterialManager {
         const bind_0 = bindings.obtain(BindGroupDescriptor.from(
             MATERIAL_BUFFER_BIND_GROUP_0_LAYOUT_DESCRIPTOR,
             [
-                mesh_texture.obtainView(),
+                visibility.obtainView(),
+                { buffer: visible_meshlets },
             ]
         ));
 
@@ -503,6 +558,7 @@ export class GPUMaterialManager {
             [
                 { buffer: view.scene.scene_database_buffer },
                 material_seen,
+                { buffer: material_slots },
             ]
         ));
 
@@ -519,22 +575,25 @@ 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,
+                         texture_visibility,
+                         visible_meshlets,
+                         texture_pbr,
                      }) {
 
         assert.defined(graph, 'graph');
-        assert.isNonNegativeInteger(texture_normal, 'texture_normal');
+        assert.isNonNegativeInteger(texture_visibility, 'texture_visibility');
+        assert.isNonNegativeInteger(visible_meshlets, 'visible_meshlets');
+        assert.isNonNegativeInteger(texture_pbr, 'texture_pbr');
         assert.defined(view, 'view');
 
         /**
@@ -545,8 +604,8 @@ export class GPUMaterialManager {
          */
         const execute = (data, resources, context) => {
 
-            const viz_mesh = resources.get(data.viz_mesh);
-            const viz_triangle = resources.get(data.viz_triangle);
+            const visibility = resources.get(data.visibility);
+            const visible_meshlets = resources.get(data.visible_meshlets);
 
             const g_pbr = resources.get(data.g_pbr);
             const g_normal = resources.get(data.g_normal);
@@ -572,9 +631,11 @@ export class GPUMaterialManager {
             this.#prepare_material_depth_buffer(
                 encoder,
                 view,
-                viz_mesh,
+                visibility,
+                visible_meshlets,
                 material_depth,
                 material_seen,
+                resources.get(data.material_slots),
             );
 
             const pass = encoder.beginRenderPass({
@@ -603,7 +664,7 @@ export class GPUMaterialManager {
                 ],
                 depthStencilAttachment: {
                     // this is our mask
-                    view: material_depth.obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
+                    view: material_depth.obtainView(),
                     depthReadOnly: true,
                 },
                 primitive: {
@@ -617,8 +678,8 @@ export class GPUMaterialManager {
                 BindGroupDescriptor.from(
                     MATERIAL_BIND_GROUP_VIZ_BUFFER,
                     [
-                        viz_triangle.obtainView(),
-                        viz_mesh.obtainView(),
+                        visibility.obtainView(),
+                        { buffer: visible_meshlets },
                         { buffer: view.uniform_buffer.buffer },
                         { buffer: view.camera.buffer.buffer },
                         material_seen,
@@ -641,7 +702,8 @@ export class GPUMaterialManager {
             pass.setBindGroup(1, bind_1)
             pass.setBindGroup(2, bind_2)
 
-            const materials = this.#gbuffer_contexts(view.scene.drawn_materials);
+            // the list the mask was written from, not whatever the manager holds by now
+            const materials = data.contexts;
             const material_count = materials.length;
 
             let cached_last_pipeline = null;
@@ -663,9 +725,9 @@ export class GPUMaterialManager {
 
                 pass.setBindGroup(0, material_ctx.material_binding);
 
-                // the id rides in the instance index; a material with no pixel in the view draws a
-                // triangle of no area, see material_gbuffer_vertex_shader_code
-                pass.draw(3, 1, 0, material_ctx.material_id);
+                // the material's place rides in the instance index; a material with no pixel in the
+                // view draws a triangle of no area, see material_gbuffer_vertex_shader_code
+                pass.draw(3, 1, 0, i);
             }
 
             pass.end();
@@ -673,22 +735,41 @@ export class GPUMaterialManager {
             encoder.popDebugGroup();
         }
 
+        // The list and its slot table as they are now. Both are replaced rather than rewritten when
+        // the list changes, so the mask and the draws agree on every material's place even if a
+        // context joins before the pass runs.
+        const drawn = view.scene.drawn_materials;
+        const contexts = this.#gbuffer_contexts(drawn);
+        const slot_table = this.#lists_of(drawn).gbuffer_slots;
+
+        assert.lessThan(contexts.length, MATERIAL_MASK_NONE, 'G-buffer materials of one view');
+
+        // added ahead of the pass that reads it, as the graph runs passes in the order they are added
+        const gr_material_slots = graph_import_raw_buffer({
+            graph,
+            value: slot_table.buffer,
+            offset: slot_table.byteOffset,
+            size: slot_table.byteLength,
+            label: "material slots",
+            usage: GPUBufferUsage.STORAGE,
+        });
+
         const pass_data = {};
 
         const pass = graph.add('Material Draw', pass_data, execute);
 
-        pass_data.viz_mesh = pass.read(texture_viz_mesh);
-        pass_data.viz_triangle = pass.read(texture_viz_triangle);
+        pass_data.visibility = pass.read(texture_visibility);
+        pass_data.visible_meshlets = pass.read(visible_meshlets);
 
-        pass_data.g_pbr = pass.create(
-            "g-buffer / PBR",
+        pass_data.g_pbr = pass.write(texture_pbr);
+        pass_data.g_normal = pass.create(
+            "g-buffer / Normal",
             TextureResourceDescriptor.from({
-                format:"rg8unorm",
+                format: G_BUFFER_COLOR_TARGETS[1].format,
                 resolution: view.resolution,
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
             })
         );
-        pass_data.g_normal = pass.write(texture_normal);
         pass_data.g_albedo = pass.create(
             "g-buffer / Albedo",
             TextureResourceDescriptor.from({
@@ -709,18 +790,17 @@ export class GPUMaterialManager {
         pass_data.material_depth = pass.create(
             'material depth texture',
             TextureResourceDescriptor.from({
-                format: 'depth32float',
+                format: MATERIAL_MASK_FORMAT,
                 resolution: view.resolution,
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
             })
         );
 
-        // a bit for every id the list holds now; one that joins before the pass runs is past the end
-        // and drawn as though seen
-        this.#gbuffer_contexts(view.scene.drawn_materials);
+        pass_data.contexts = contexts;
+        pass_data.material_slots = pass.read(gr_material_slots);
 
-        const id_bound = this.#lists_of(view.scene.drawn_materials).gbuffer_id_bound;
-        const material_seen_words = Math.max(1, Math.ceil(id_bound / 32));
+        // a bit for every place in the list
+        const material_seen_words = Math.max(1, Math.ceil(contexts.length / 32));
 
         pass_data.material_seen_size = material_seen_words * 4;
         pass_data.material_seen = pass.create(
@@ -904,7 +984,9 @@ 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[]}
@@ -913,6 +995,21 @@ export class GPUMaterialManager {
         return this.#gbuffer_contexts(drawn);
     }
 
+    /**
+     * 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) {
+        this.#gbuffer_contexts(drawn);
+
+        return this.#lists_of(drawn).gbuffer_slots;
+    }
+
     /**
      * Moves whenever {@link gbuffer_contexts} may answer differently for the same drawn set.
      *
@@ -940,11 +1037,9 @@ export class GPUMaterialManager {
 
         if (lists.gbuffer_version !== this.#list_version) {
             const sorted = lists.sorted;
-            const contexts = lists.gbuffer;
 
-            contexts.length = 0;
-
-            let id_bound = 0;
+            // a new array, so a pass that captured the old one keeps the places it was recorded with
+            const contexts = [];
 
             for (let i = 0; i < sorted.length; i++) {
                 const material = sorted[i];
@@ -961,11 +1056,10 @@ export class GPUMaterialManager {
                 }
 
                 contexts.push(material_ctx);
-
-                id_bound = Math.max(id_bound, material_ctx.material_id + 1);
             }
 
-            lists.gbuffer_id_bound = id_bound;
+            lists.gbuffer = contexts;
+            lists.gbuffer_slots = build_slot_table(contexts);
             lists.gbuffer_version = this.#list_version;
         }
 

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

@@ -0,0 +1,19 @@
+/**
+ * Format of the G-buffer pass's material mask: a depth target holding, at each pixel, the place in
+ * the pass's list of the material the visibility buffer names there, as `place / MATERIAL_MASK_NONE`.
+ * A material's draw is a full-screen triangle at its own place's depth, tested `equal` against it.
+ *
+ * A place, not a material id: ids come from one counter for the life of the process and are never
+ * reused, so only a material's place in the list is bounded by what one pass can draw.
+ *
+ * @type {GPUTextureFormat}
+ */
+export const MATERIAL_MASK_FORMAT: GPUTextureFormat;
+/**
+ * The mask's value where no listed material holds the pixel: the cleared depth, 1.0. Every place in
+ * the G-buffer pass's list is below it, so the list holds fewer materials than this.
+ *
+ * @type {number}
+ */
+export const MATERIAL_MASK_NONE: number;
+//# sourceMappingURL=MATERIAL_MASK.d.ts.map