@woosh/meep-engine 3.61.3 → 3.62.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"MATERIAL_MASK.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/MATERIAL_MASK.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,oDAAmD;AAEnD;;;;;GAKG;AACH,iCAFU,MAAM,CAEwB"}

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

@@ -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 = 'depth16unorm';
+
+/**
+ * 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 = 65535;

package/src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.d.ts

@@ -33,18 +33,18 @@ export class GPUMaterialComputeDispatch {
      * @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, with `STORAGE_BINDING`
+     * @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, with `STORAGE_BINDING`
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}}
      */
-    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;

package/src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMaterialComputeDispatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.js"],"names":[],"mappings":"AA0DA;;;;;;;;;;;;;GAaG;AACH;IA8DI;;;;;;OAMG;IACH;QAL8B,MAAM;QACG,SAAS,EAArC,kBAAkB;QACc,iBAAiB,EAAjD,sBAAsB;QACI,QAAQ,EAAlC,gBAAgB;OAa1B;IAED;;;;;;;;;;;;OAYG;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,CA0BnF;IAED;;;;;;OAMG;IACH,0BAFW,eAAe,QAazB;IAED,gBAOC;;CAqHJ;yBAlUY,OAAO,8DAA8D,EAAE,UAAU;wCACjF,OAAO,mEAAmE,EAAE,yBAAyB;qCACrG,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,6CAA6C,EAAE,eAAe;+BACrE,OAAO,mCAAmC,EAAE,gBAAgB;6BAC5D,OAAO,8BAA8B,EAAE,cAAc;iCACrD,OAAO,0BAA0B,EAAE,kBAAkB;iCACrD,OAAO,0BAA0B,EAAE,kBAAkB;4BACrD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,sCAAsC,EAAE,qBAAqB"}
+{"version":3,"file":"GPUMaterialComputeDispatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;GAaG;AACH;IAgDI;;;;;;OAMG;IACH;QAL8B,MAAM;QACG,SAAS,EAArC,kBAAkB;QACc,iBAAiB,EAAjD,sBAAsB;QACI,QAAQ,EAAlC,gBAAgB;OAa1B;IAED;;;;;;;;;;;;OAYG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,kBAAkB,EAAlC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACU,WAAW,EAA3B,MAAM;QAEJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA0BnF;IAED;;;;;;OAMG;IACH,0BAFW,eAAe,QAazB;IAED,gBAMC;;CAsEJ;yBArPY,OAAO,8DAA8D,EAAE,UAAU;wCACjF,OAAO,mEAAmE,EAAE,yBAAyB;qCACrG,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,6CAA6C,EAAE,eAAe;+BACrE,OAAO,mCAAmC,EAAE,gBAAgB;6BAC5D,OAAO,8BAA8B,EAAE,cAAc;iCACrD,OAAO,0BAA0B,EAAE,kBAAkB;iCACrD,OAAO,0BAA0B,EAAE,kBAAkB;4BACrD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,sCAAsC,EAAE,qBAAqB"}

package/src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.js

@@ -1,8 +1,4 @@
 import { assert } from "../../../../core/assert.js";
-import {
-    cpu_hash_table_create,
-    cpu_hash_table_word_count
-} from "../../gpu_primitive/hash_table/cpu_build_hash_table.js";
 import { enquire_prefix_scan_csdldf_pipelines } from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
 import { STANDARD_MATERIAL_TEMPLATE } from "../standard/STANDARD_MATERIAL_TEMPLATE.js";
 import { build_gbuffer_compute_pipeline_descriptor } from "./gbuffer_compute.js";
@@ -41,21 +37,6 @@ class ComputeMaterialGroup {
     group;
 }
 
-/**
- * The material id → slot table of one drawn set, and the list version it was built at.
- */
-class MaterialSlotTable {
-    /**
-     * @type {Uint32Array}
-     */
-    table = new Uint32Array(0);
-
-    /**
-     * @type {number}
-     */
-    version = -1;
-}
-
 /**
  * The G-buffer pass as {@link MaterialDispatch.Compute} runs it — **experimental, off by default, not
  * the main path**; why, with the measurements, is in `COMPUTE_MATERIAL_DISPATCH.md` beside this file.
@@ -108,20 +89,6 @@ export class GPUMaterialComputeDispatch {
      */
     #groups = new WeakMap();
 
-    /**
-     * Per drawn set, which the scene replaces when it changes. Weak, as the manager's lists are.
-     *
-     * @type {WeakMap<ShadeMaterial[], MaterialSlotTable>}
-     */
-    #slot_tables = new WeakMap();
-
-    /**
-     * The table being built, kept to build the next one in.
-     *
-     * @type {number[]}
-     */
-    #slot_ids = [];
-
     /**
      * @type {function(GPUMaterialContext):GPUComputePipeline}
      */
@@ -159,18 +126,18 @@ export class GPUMaterialComputeDispatch {
      * @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, with `STORAGE_BINDING`
+     * @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, with `STORAGE_BINDING`
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}}
      */
     graph_viz_render({
                          graph,
                          view,
-                         texture_viz_mesh,
-                         texture_viz_triangle,
-                         texture_normal,
+                         texture_visibility,
+                         visible_meshlets,
+                         texture_pbr,
                      }) {
         const drawn = view.scene.drawn_materials;
 
@@ -180,14 +147,14 @@ export class GPUMaterialComputeDispatch {
             graph,
             view,
             contexts,
-            material_slots: this.#slot_table(drawn, contexts),
+            material_slots: this.#materials.gbuffer_slot_table(drawn),
             records: this.#records,
             bindings: this.#bindings,
             pipeline_of: this.#pipeline_of,
             group_of: this.#group_of,
-            texture_viz_mesh,
-            texture_viz_triangle,
-            texture_normal,
+            texture_visibility,
+            visible_meshlets,
+            texture_pbr,
         });
     }
 
@@ -217,7 +184,6 @@ export class GPUMaterialComputeDispatch {
         this.#pipelines.clear();
         this.#pipeline_descriptors.clear();
         this.#groups = new WeakMap();
-        this.#slot_tables = new WeakMap();
     }
 
     /**
@@ -288,51 +254,4 @@ export class GPUMaterialComputeDispatch {
 
         return entry.group;
     }
-
-    /**
-     * Each context's place among `contexts`, by material id, rebuilt when the manager's list moves.
-     *
-     * @param {ShadeMaterial[]} drawn
-     * @param {GPUMaterialContext[]} contexts what the manager answers for `drawn`
-     * @returns {Uint32Array}
-     */
-    #slot_table(drawn, contexts) {
-        let slots = this.#slot_tables.get(drawn);
-
-        if (slots === undefined) {
-            slots = new MaterialSlotTable();
-
-            this.#slot_tables.set(drawn, slots);
-        }
-
-        const version = this.#materials.gbuffer_contexts_version;
-
-        if (slots.version !== version) {
-            const count = contexts.length;
-            const ids = this.#slot_ids;
-
-            ids.length = count;
-
-            for (let i = 0; i < count; i++) {
-                ids[i] = contexts[i].material_id;
-            }
-
-            let table = slots.table;
-
-            const word_count = cpu_hash_table_word_count(count);
-
-            if (table.length < word_count) {
-                table = new Uint32Array(word_count);
-            }
-
-            while (!cpu_hash_table_create(table, ids, count)) {
-                table = new Uint32Array(table.length * 2);
-            }
-
-            slots.table = table;
-            slots.version = version;
-        }
-
-        return slots.table;
-    }
 }

package/src/shade/renderer/material/dispatch/chunk_material_quad_keys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_material_quad_keys.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/chunk_material_quad_keys.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH,uCAFU,SAAS,CAyFhB;0BA5GuB,oCAAoC"}
+{"version":3,"file":"chunk_material_quad_keys.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/chunk_material_quad_keys.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;GAgBG;AACH,uCAFU,SAAS,CAgGhB;0BAnHuB,oCAAoC"}

package/src/shade/renderer/material/dispatch/chunk_material_quad_keys.js

@@ -1,4 +1,5 @@
 import { VIZ_BUFFER_INVALID_MESH_VALUE } from "../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+import { chunk_visibility_decode } from "../../rasterize/visibility/chunk_visibility_decode.js";
 import { SUBGROUP_KEYED_APPEND_NONE } from "../../shader/chunk/subgroup/chunk_subgroup_keyed_append.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { chunk_material_mesh_key } from "./chunk_material_mesh_key.js";
@@ -29,7 +30,7 @@ struct MaterialQuadKeys {
     masks: vec4<u32>,
 }
 
-// the mesh at a corner, or none for a corner off the view
+// the mesh at a corner, or none for a corner off the view or of no surface
 fn material_quad_mesh(quad: vec2<u32>, corner: vec2<u32>, resolution: vec2<u32>) -> u32 {
     let pixel = quad * 2u + corner;
 
@@ -37,7 +38,13 @@ fn material_quad_mesh(quad: vec2<u32>, corner: vec2<u32>, resolution: vec2<u32>)
         return ${VIZ_BUFFER_INVALID_MESH_VALUE}u;
     }
 
-    return textureLoad(viz_buffer_mesh, vec2<i32>(pixel), 0).r;
+    let encoded = textureLoad(visibility, vec2<i32>(pixel), 0).r;
+
+    if (encoded == VISIBILITY_NONE) {
+        return ${VIZ_BUFFER_INVALID_MESH_VALUE}u;
+    }
+
+    return visibility_decode(encoded).mesh;
 }
 
 // put a corner's key in its place among the distinct keys, written out rather than indexed: a
@@ -108,4 +115,5 @@ fn material_quad_keys(quad: vec2<u32>, resolution: vec2<u32>, tiles_x: u32, tile
 }
 `, [
     chunk_material_mesh_key,
+    chunk_visibility_decode,
 ]);

package/src/shade/renderer/material/dispatch/gbuffer_compute.js

@@ -205,8 +205,8 @@ fn main(
     let g = gbuffer_laydown(vec2<f32>(pixel) + vec2<f32>(0.5));
 
     if (in_list && ((entry.mask >> corner) & 1u) != 0u) {
-        textureStore(g_buffer_pbr, pixel, vec4<f32>(g.pbr, 0.0, 0.0));
-        textureStore(g_buffer_normal, pixel, g.normal);
+        textureStore(g_buffer_pbr, pixel, g.pbr);
+        textureStore(g_buffer_normal, pixel, vec4<u32>(g.normal, 0u, 0u, 0u));
         textureStore(g_buffer_albedo, pixel, g.albedo);
         textureStore(g_buffer_emissive, pixel, vec4<u32>(g.emissive, 0u, 0u, 0u));
     }

package/src/shade/renderer/material/dispatch/graph_material_dispatch_compute.d.ts

@@ -25,12 +25,12 @@
  *   compute G-buffer pipeline
  * @param {function(GPUMaterialContext):GPUBindGroup} options.group_of the context's group 0 for
  *   that pipeline
- * @param {number} options.texture_viz_mesh
- * @param {number} options.texture_viz_triangle
- * @param {number} options.texture_normal
+ * @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, which outlives the frame
  * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}}
  */
-export function graph_material_dispatch_compute({ graph, view, contexts, material_slots, records, bindings, pipeline_of, group_of, texture_viz_mesh, texture_viz_triangle, texture_normal, }: {
+export function graph_material_dispatch_compute({ graph, view, contexts, material_slots, records, bindings, pipeline_of, group_of, texture_visibility, visible_meshlets, texture_pbr, }: {
     graph: FrameGraph;
     view: GPUViewContext;
     contexts: GPUMaterialContext[];
@@ -39,9 +39,9 @@ export function graph_material_dispatch_compute({ graph, view, contexts, materia
     bindings: BindGroupManager;
     pipeline_of: (arg0: GPUMaterialContext) => GPUComputePipeline;
     group_of: (arg0: GPUMaterialContext) => GPUBindGroup;
-    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;

package/src/shade/renderer/material/dispatch/graph_material_dispatch_compute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_material_dispatch_compute.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/graph_material_dispatch_compute.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IAjB+B,KAAK,EAAzB,UAAU;IACc,IAAI,EAA5B,cAAc;IACgB,QAAQ,EAAtC,kBAAkB,EAAE;IAEC,cAAc,EAAnC,WAAW;IAEsB,OAAO,EAAxC,uBAAuB;IACG,QAAQ,EAAlC,gBAAgB;IACyC,WAAW,SAA3D,kBAAkB;IAEwB,QAAQ,SAAlD,kBAAkB;IAEX,gBAAgB,EAAhC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,cAAc,EAA9B,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CA0OnF;yBA/RY,OAAO,8DAA8D,EAAE,UAAU;+BACjF,OAAO,mCAAmC,EAAE,gBAAgB;6BAC5D,OAAO,8BAA8B,EAAE,cAAc;iCACrD,OAAO,0BAA0B,EAAE,kBAAkB;sCACrD,OAAO,8BAA8B,EAAE,uBAAuB"}
+{"version":3,"file":"graph_material_dispatch_compute.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/graph_material_dispatch_compute.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IAjB+B,KAAK,EAAzB,UAAU;IACc,IAAI,EAA5B,cAAc;IACgB,QAAQ,EAAtC,kBAAkB,EAAE;IAEC,cAAc,EAAnC,WAAW;IAEsB,OAAO,EAAxC,uBAAuB;IACG,QAAQ,EAAlC,gBAAgB;IACyC,WAAW,SAA3D,kBAAkB;IAEwB,QAAQ,SAAlD,kBAAkB;IAEX,kBAAkB,EAAlC,MAAM;IACU,gBAAgB,EAAhC,MAAM;IACU,WAAW,EAA3B,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CA8OnF;yBAnSY,OAAO,8DAA8D,EAAE,UAAU;+BACjF,OAAO,mCAAmC,EAAE,gBAAgB;6BAC5D,OAAO,8BAA8B,EAAE,cAAc;iCACrD,OAAO,0BAA0B,EAAE,kBAAkB;sCACrD,OAAO,8BAA8B,EAAE,uBAAuB"}

package/src/shade/renderer/material/dispatch/graph_material_dispatch_compute.js

@@ -75,9 +75,9 @@ function storage_target(format, resolution) {
  *   compute G-buffer pipeline
  * @param {function(GPUMaterialContext):GPUBindGroup} options.group_of the context's group 0 for
  *   that pipeline
- * @param {number} options.texture_viz_mesh
- * @param {number} options.texture_viz_triangle
- * @param {number} options.texture_normal
+ * @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, which outlives the frame
  * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}}
  */
 export function graph_material_dispatch_compute({
@@ -89,9 +89,9 @@ export function graph_material_dispatch_compute({
                                                     bindings,
                                                     pipeline_of,
                                                     group_of,
-                                                    texture_viz_mesh,
-                                                    texture_viz_triangle,
-                                                    texture_normal,
+                                                    texture_visibility,
+                                                    visible_meshlets,
+                                                    texture_pbr,
                                                 }) {
     assert.defined(graph, 'graph');
     assert.defined(view, 'view');
@@ -140,7 +140,8 @@ export function graph_material_dispatch_compute({
         shader_material_pixel_count.dispatch({
             encoder,
             bindings: {
-                viz_buffer_mesh: resources.get(data.viz_mesh).obtainView(),
+                visibility: resources.get(data.visibility).obtainView(),
+                visible_meshlets: resources.get(data.visible_meshlets),
                 material_slots: resources.get(data.material_slots),
                 counts: resources.get(data.counts),
                 settings: encoder.allocateTransientValueBuffer(MATERIAL_CLASSIFY_SETTINGS_STRUCT, classify_settings, GPUBufferUsage.UNIFORM),
@@ -155,14 +156,15 @@ export function graph_material_dispatch_compute({
         });
     });
 
-    count_data.viz_mesh = count_pass.read(texture_viz_mesh);
+    count_data.visibility = count_pass.read(texture_visibility);
+    count_data.visible_meshlets = count_pass.read(visible_meshlets);
     count_data.material_slots = count_pass.read(gr_material_slots);
     count_data.counts = count_pass.create("material pixel counts", BufferResourceDescriptor.empty(
         round_up(16 + list_count * 4, 16),
         GPUBufferUsage.STORAGE
     ));
-    count_data.g_pbr = count_pass.create("g-buffer / PBR", storage_target(G_BUFFER_COLOR_TARGETS[0].format, resolution));
-    count_data.g_normal = count_pass.write(texture_normal);
+    count_data.g_pbr = count_pass.write(texture_pbr);
+    count_data.g_normal = count_pass.create("g-buffer / Normal", storage_target(G_BUFFER_COLOR_TARGETS[1].format, resolution));
     count_data.g_albedo = count_pass.create("g-buffer / Albedo", storage_target(G_BUFFER_COLOR_TARGETS[2].format, resolution));
     count_data.g_emissive = count_pass.create("g-buffer / Emissive", storage_target(G_BUFFER_COLOR_TARGETS[3].format, resolution));
 
@@ -209,7 +211,8 @@ export function graph_material_dispatch_compute({
         shader_material_pixel_scatter.dispatch({
             encoder,
             bindings: {
-                viz_buffer_mesh: resources.get(data.viz_mesh).obtainView(),
+                visibility: resources.get(data.visibility).obtainView(),
+                visible_meshlets: resources.get(data.visible_meshlets),
                 material_slots: resources.get(data.material_slots),
                 settings: encoder.allocateTransientValueBuffer(MATERIAL_CLASSIFY_SETTINGS_STRUCT, classify_settings, GPUBufferUsage.UNIFORM),
                 offsets: resources.get(data.offsets),
@@ -222,7 +225,8 @@ export function graph_material_dispatch_compute({
         });
     });
 
-    scatter_data.viz_mesh = scatter_pass.read(texture_viz_mesh);
+    scatter_data.visibility = scatter_pass.read(texture_visibility);
+    scatter_data.visible_meshlets = scatter_pass.read(visible_meshlets);
     scatter_data.material_slots = scatter_pass.read(gr_material_slots);
     scatter_data.offsets = scatter_pass.read(gr_offsets);
     scatter_data.cursors = scatter_pass.create("material pixel cursors", BufferResourceDescriptor.empty(
@@ -252,8 +256,8 @@ export function graph_material_dispatch_compute({
         assert.equal(record_buffer, records.buffer, 'the dispatch records were replaced between recording and executing the frame');
 
         const bind_1 = bindings.obtain(BindGroupDescriptor.from(GBUFFER_COMPUTE_VIZ_LAYOUT, [
-            resources.get(data.viz_triangle).obtainView(),
-            resources.get(data.viz_mesh).obtainView(),
+            resources.get(data.visibility).obtainView(),
+            { buffer: resources.get(data.visible_meshlets) },
             { buffer: view.uniform_buffer.buffer },
             { buffer: view.camera.buffer.buffer },
             { buffer: resources.get(data.material_quads) },
@@ -297,8 +301,8 @@ export function graph_material_dispatch_compute({
         pass.end();
     });
 
-    shade_data.viz_triangle = shade_pass.read(texture_viz_triangle);
-    shade_data.viz_mesh = shade_pass.read(texture_viz_mesh);
+    shade_data.visibility = shade_pass.read(texture_visibility);
+    shade_data.visible_meshlets = shade_pass.read(visible_meshlets);
     shade_data.material_quads = shade_pass.read(scatter_data.material_quads);
     shade_data.records = shade_pass.read(commands_data.records);
     shade_data.g_pbr = shade_pass.write(shade_pass.read(count_data.g_pbr));

package/src/shade/renderer/material/dispatch/shader_material_pixel_count.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_material_pixel_count.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/shader_material_pixel_count.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,gDAFU,YAAY,CAgBS;AAgF/B;;;;;;;;;;;GAWG;AACH,0CAFU,aAAa,CAMpB;6BA1H0B,mCAAmC;8BAJlC,+BAA+B"}
+{"version":3,"file":"shader_material_pixel_count.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/shader_material_pixel_count.js"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH,gDAFU,YAAY,CAgBS;AAiF/B;;;;;;;;;;;GAWG;AACH,0CAFU,aAAa,CAMpB;6BA3H0B,mCAAmC;8BALlC,+BAA+B"}

package/src/shade/renderer/material/dispatch/shader_material_pixel_count.js

@@ -5,6 +5,7 @@ import {
 } from "../../shader/chunk/subgroup/chunk_subgroup_keyed_append.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
+import { VISIBLE_MESHLETS_RESOURCE } from "../../rasterize/visibility/chunk_visibility_decode.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { atomic_u32, u32, vec2u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
@@ -39,7 +40,8 @@ export const MATERIAL_CLASSIFY_SETTINGS_STRUCT = WebGPUStruct.from({
 const resources = new ShaderResourceSetDescriptor();
 
 resources.createGroup()
-    .addTexture("viz_buffer_mesh", "uint")
+    .addTexture("visibility", "uint")
+    .add(VISIBLE_MESHLETS_RESOURCE)
     .addStorageBuffer("material_slots", WebGPUArray.u32)
     // laid out as graph_prefix_scan_csdldf takes its input, so the counts are scanned where they lie
     .addStorageBuffer("counts", WebGPUStruct.fromFields(

package/src/shade/renderer/material/dispatch/shader_material_pixel_scatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_material_pixel_scatter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/shader_material_pixel_scatter.js"],"names":[],"mappings":"AAkFA;;;;;;;;;;GAUG;AACH,4CAFU,aAAa,CAMpB;8BA3F2B,+BAA+B"}
+{"version":3,"file":"shader_material_pixel_scatter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/shader_material_pixel_scatter.js"],"names":[],"mappings":"AAoFA;;;;;;;;;;GAUG;AACH,4CAFU,aAAa,CAMpB;8BA7F2B,+BAA+B"}

package/src/shade/renderer/material/dispatch/shader_material_pixel_scatter.js

@@ -5,6 +5,7 @@ import {
 } from "../../shader/chunk/subgroup/chunk_subgroup_keyed_append.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
+import { VISIBLE_MESHLETS_RESOURCE } from "../../rasterize/visibility/chunk_visibility_decode.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { atomic_u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
@@ -16,7 +17,8 @@ import { MATERIAL_CLASSIFY_SETTINGS_STRUCT } from "./shader_material_pixel_count
 const resources = new ShaderResourceSetDescriptor();
 
 resources.createGroup()
-    .addTexture("viz_buffer_mesh", "uint")
+    .addTexture("visibility", "uint")
+    .add(VISIBLE_MESHLETS_RESOURCE)
     .addStorageBuffer("material_slots", WebGPUArray.u32)
     .addUniform("settings", MATERIAL_CLASSIFY_SETTINGS_STRUCT)
     // inclusive sums of the counts, so a list starts where the one before it ends

package/src/shade/renderer/material/standard/fragment_gbuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AAkFA;;;;;;GAMG;AACH,kDAHW,6BAA6B,GAC3B,6BAA6B,CASzC;AAoBD;;;;;;;;GAQG;AACH,+DAHW,6BAA6B,GAC3B,2BAA2B,CAUvC;AASD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CALW,SAAS,eACT,SAAS,GAEP,SAAS,CA+OrB;AAgBD;;;;;;GAMG;AACH,qDAHW,SAAS,GACP,SAAS,CAerB;AAED;;;;;;;;;GASG;AACH;IAL2B,KAAK,EAArB,MAAM;IACiC,cAAc,EAArD,6BAA6B;IACV,OAAO,EAA1B,SAAS;IACP,wBAAwB,CAUpC;AAED;;;;;;;GAOG;AACH,8DAJW,MAAM,UACN,gBAAgB,GACd,wBAAwB,CA4BpC;AA3bD;;;GAGG;AAGH;;;;;;;;;GASG;AACH,qCAFU,6BAA6B,CAEmC;AA8B1E;;;;GAIG;AACH,uCAFU,6BAA6B,CAEqC;AAgC5E;;;;GAIG;AACH,wCAFU,2BAA2B,CAEoE;AAyQzG;;;;;GAKG;AACH,4CAFU,SAAS,CAQhB;AAgFH;;;;GAIG;AACH,6BAFU,gBAAgB,CAMvB;8CA/c2C,wDAAwD;4CAC1D,sDAAsD;0BAFxE,oCAAoC;yCAxCrB,iEAAiE;iCA2CzE,kCAAkC"}
+{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AA0FA;;;;;;GAMG;AACH,kDAHW,6BAA6B,GAC3B,6BAA6B,CASzC;AAoBD;;;;;;;;GAQG;AACH,+DAHW,6BAA6B,GAC3B,2BAA2B,CAUvC;AASD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CALW,SAAS,eACT,SAAS,GAEP,SAAS,CAwOrB;AAgBD;;;;;;GAMG;AACH,qDAHW,SAAS,GACP,SAAS,CAerB;AAED;;;;;;;;;GASG;AACH;IAL2B,KAAK,EAArB,MAAM;IACiC,cAAc,EAArD,6BAA6B;IACV,OAAO,EAA1B,SAAS;IACP,wBAAwB,CAUpC;AAED;;;;;;;GAOG;AACH,8DAJW,MAAM,UACN,gBAAgB,GACd,wBAAwB,CA4BpC;AApbD;;;GAGG;AAGH;;;;;;;;;GASG;AACH,qCAFU,6BAA6B,CAEmC;AA8B1E;;;;GAIG;AACH,uCAFU,6BAA6B,CAEqC;AAgC5E;;;;GAIG;AACH,wCAFU,2BAA2B,CAEoE;AAkQzG;;;;;GAKG;AACH,4CAFU,SAAS,CAQhB;AAgFH;;;;GAIG;AACH,6BAFU,gBAAgB,CAMvB;8CAzc2C,wDAAwD;4CAC1D,sDAAsD;0BAFxE,oCAAoC;yCA/CrB,iEAAiE;iCAkDzE,kCAAkC"}

package/src/shade/renderer/material/standard/fragment_gbuffer.js

@@ -16,7 +16,10 @@ import { chunk_barycentric_interpolate_uv } from "../../shader/chunk/geometry/tr
 import { chunk_compute_normal_matrix_from_m4 } from "../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
 import { chunk_rgbe9995_encode } from "../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.js";
 import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
-import { chunk_decode_meshlet_element } from "../../shader/chunk/geometry/meshlet/chunk_decode_meshlet_element.js";
+import {
+    chunk_visibility_decode,
+    VISIBLE_MESHLETS_RESOURCE
+} from "../../rasterize/visibility/chunk_visibility_decode.js";
 import {
     chunk_read_meshlet_triangle_vertices
 } from "../../shader/chunk/geometry/meshlet/chunk_read_meshlet_triangle_vertices.js";
@@ -30,7 +33,11 @@ import {
     chunk_compute_triangle_face_normal
 } from "../../shader/chunk/geometry/normal/chunk_compute_triangle_face_normal.js";
 
+import { chunk_encode_g_buffer_albedo } from "../../shader/chunk/material/chunk_encode_g_buffer_albedo.js";
 import { chunk_encode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_encode_g_buffer_normal.js";
+import {
+    chunk_encode_g_buffer_face_normal
+} from "../../shader/chunk/geometry/normal/chunk_encode_g_buffer_face_normal.js";
 import {
     chunk_interpolate_attribute_3f32
 } from "../../shader/chunk/geometry/triangle/chunk_interpolate_attribute_3f32.js";
@@ -45,6 +52,7 @@ import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResou
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
+import { MATERIAL_MASK_FORMAT } from "../MATERIAL_MASK.js";
 import { chunk_material_surface_contract } from "../template/chunk_material_surface.js";
 import { chunk_standard_material_surface } from "./chunk_standard_material_surface.js";
 import { MATERIAL_SEEN_BINDING, material_gbuffer_vertex_shader_code } from "./material_gbuffer_vertex.js";
@@ -89,8 +97,8 @@ assert.equal(g_buffer_viz_resources.get("material_seen").binding_index, MATERIAL
  */
 export function add_g_buffer_viz_resources(group) {
     return group
-        .addTexture("viz_buffer_triangle", "uint")
-        .addTexture("viz_buffer_mesh", "uint")
+        .addTexture("visibility", "uint")
+        .add(VISIBLE_MESHLETS_RESOURCE)
         .addUniform("view", VIEW_UNIFORM_STRUCT)
         .addUniform("camera", CAMERA_UNIFORM_STRUCT)
         ;
@@ -169,8 +177,8 @@ export function build_gbuffer_laydown(surface, derivatives) {
 // language=WGSL
         `
 struct GBufferOutput {
-  @location(0) pbr : vec2<f32>,
-  @location(1) normal : vec4<u32>,
+  @location(0) pbr : vec4<f32>,
+  @location(1) normal : u32,
   @location(2) albedo : vec4<f32>,
   @location(3) emissive : u32,
 }
@@ -180,21 +188,15 @@ fn gbuffer_laydown(
 ) -> GBufferOutput {
     var output : GBufferOutput;
 
-    let encoded_meshlet_triangle = textureLoad(
-        viz_buffer_triangle,
+    let visibility_texel = visibility_decode(textureLoad(
+        visibility,
         vec2<i32>(coord),
         0
-    ).r;
-
-    let decoded_meshlet_triangle = decode_meshlet_element(encoded_meshlet_triangle);
-    let meshlet_id = decoded_meshlet_triangle[0];
-    let meshlet_triangle_id = decoded_meshlet_triangle[1];
+    ).r);
 
-    let mesh_index = textureLoad(
-        viz_buffer_mesh,
-        vec2<i32>(coord),
-        0
-    ).r;
+    let meshlet_id = visibility_texel.meshlet;
+    let meshlet_triangle_id = visibility_texel.triangle;
+    let mesh_index = visibility_texel.mesh;
 
     let mesh = scene_read_mesh(&scene_database, mesh_index);
     let node = scene_read_node(&scene_database, mesh.node);
@@ -360,16 +362,13 @@ fn gbuffer_laydown(
     let output_roughness = filtered_roughness + dither_color_8bit_triangle_noise(coord);
 
     output.albedo = vec4<f32>(
-        surface.albedo,
+        encode_g_buffer_albedo(surface.albedo),
         surface.ambient
     );
 
-    output.normal = vec4u(
-        encode_g_buffer_normal(world_shading_normal),
-        encode_g_buffer_normal(world_face_normal),
-    );
+    output.normal = encode_g_buffer_normal(world_shading_normal);
 
-    output.pbr = vec2(surface.metalness, output_roughness);
+    output.pbr = vec4(surface.metalness, output_roughness, encode_g_buffer_face_normal(world_face_normal));
 
     output.emissive = rgbe9995_encode(surface.emissive);
 
@@ -380,7 +379,9 @@ fn gbuffer_laydown(
         chunk_material_surface_contract,
 
         chunk_mat4_extract_position,
+        chunk_encode_g_buffer_albedo,
         chunk_encode_g_buffer_normal,
+        chunk_encode_g_buffer_face_normal,
 
         chunk_interpolate_attribute_3f32,
         chunk_interpolate_with_derivatives,
@@ -392,7 +393,7 @@ fn gbuffer_laydown(
         chunk_anti_alias_roughness_kaplanyan_footprint,
         chunk_build_orthonormal_matrix_nt,
         chunk_read_meshlet_triangle_vertices,
-        chunk_decode_meshlet_element,
+        chunk_visibility_decode,
         chunk_compute_triangle_face_normal,
         chunk_rgbe9995_encode,
         chunk_dither_color_8bit_triangle_noise,
@@ -485,7 +486,7 @@ export function gbuffer_pipeline_descriptor_for_shader(label, shader) {
         depthStencil: {
             // depth is actually a material mask, we use trick from Unreal to mask materials using depth
             depthCompare: 'equal',
-            format: 'depth32float',
+            format: MATERIAL_MASK_FORMAT,
             depthWriteEnabled: false
         },
         primitive: {

package/src/shade/renderer/material/standard/material_gbuffer_vertex.d.ts

@@ -1,26 +1,28 @@
 /**
  * Group 1 binding of the material-seen bitset the shared G-buffer vertex stage reads: bit
- * `id & 31` of word `id >> 5` is set when material `id` holds a pixel of the view.
+ * `place & 31` of word `place >> 5` is set when the material at that place in the G-buffer pass's
+ * list holds a pixel of the view.
  *
  * @type {number}
  */
 export const MATERIAL_SEEN_BINDING: number;
 /**
  * Shared vertex stage of every material template's G-buffer pipeline: a fullscreen triangle placed
- * at depth `material.id / 2^24`, matched against the material-depth mask with `depthCompare: 'equal'`
+ * at depth `place / MATERIAL_MASK_NONE`, matched against the material mask with `depthCompare: 'equal'`
  * so the fragment stage only runs on this material's pixels.
  *
- * The material id rides in the instance index — the material pass draws `draw(3, 1, 0, id)` — so a
- * template's group 0 can be laid out however the template needs, and is visible to the fragment
- * stage alone. A direct draw's `firstInstance` needs no device feature.
+ * The material's place in the pass's list rides in the instance index — the material pass draws
+ * `draw(3, 1, 0, place)` — so a template's group 0 can be laid out however the template needs, and
+ * is visible to the fragment stage alone. A direct draw's `firstInstance` needs no device feature.
  *
  * A material that holds no pixel of the view — its bit clear in `material_seen`, of the shared group
  * 1 — gets all three corners on one point: a triangle of no area, which rasterizes nothing, so the
- * draw costs three vertex invocations rather than a fullscreen pass of depth tests. An id past the
+ * draw costs three vertex invocations rather than a fullscreen pass of depth tests. A place past the
  * end of the bitset is drawn.
  *
- * `id / 16777216` is the expression the material-depth pass writes, and a division by a power of two
- * is exact for every id below 2^24, so the two meet at depth-equal.
+ * `place / MATERIAL_MASK_NONE` is the expression the material-depth pass writes, and both are
+ * quantised to the same 16-bit code for every place below MATERIAL_MASK_NONE, so the two meet at
+ * depth-equal.
  *
  * @type {string}
  */

package/src/shade/renderer/material/standard/material_gbuffer_vertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"material_gbuffer_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/material_gbuffer_vertex.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;;;;;;;;;;;;;;;GAkBG;AACH,kDAFU,MAAM,CAqCE"}
+{"version":3,"file":"material_gbuffer_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/material_gbuffer_vertex.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,kDAFU,MAAM,CAqCE"}