@woosh/meep-engine 3.61.2 → 3.62.0

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/resident/GPUResidentMaterialContext.d.ts

@@ -45,7 +45,7 @@ export class GPUResidentMaterialContext {
      * the same contract {@link GPUMaterialManager} restages by. A hit used to be final, so a factor
      * set after the first pack never reached the row. Every caller re-obtains what it needs before
      * {@link update} or {@link commit}: the scene's drawn list, the manager's materials whenever its
-     * version moves, or what a card capture traces, so the check rides on walks that already happen.
+     * version moves, or what a surface bake traces, so the check rides on walks that already happen.
      *
      * @param {ShadeMaterial} material
      * @returns {MaterialInfo}

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAgIA;IAqKI;;;;OAIG;IACH,yCAFW,eAAe,EAkDzB;IA9LD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IAmED;;;;;OAKG;IACH,0BAEC;IAOD;;;;;;OAMG;IACH,8BAEC;IAsJD;;;;;;;;;OASG;IACH,0BAHW,aAAa,GACX,YAAY,CAmBxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA0DC;IAuFD,wBA8EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD;;;;OAIG;IACH,eAGC;IAED;;;OAGG;IACH,eAGC;IAGD,gBAIC;;CACJ;8BA9vBY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,qCAAqC,EAAE,mBAAmB;kCAlB5C,oCAAoC;AAYtE;;;;;;;GAOG;AAEH;IACI,WAAM;IAEN;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;;;OAIG;IACH,gBAFU,WAAW,GAAC,IAAI,CAEZ;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEe;CAClC;AAqBD;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}
+{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAgHA;IAqKI;;;;OAIG;IACH,yCAFW,eAAe,EAkDzB;IA9LD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IAmED;;;;;OAKG;IACH,0BAEC;IAOD;;;;;;OAMG;IACH,8BAEC;IAsJD;;;;;;;;;OASG;IACH,0BAHW,aAAa,GACX,YAAY,CAmBxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA0DC;IAuFD,wBA8EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD;;;;OAIG;IACH,eAGC;IAED;;;OAGG;IACH,eAGC;IAGD,gBAIC;;CACJ;8BA7uBY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,qCAAqC,EAAE,mBAAmB;kCAnB5C,oCAAoC;AAatE;;;;;;;GAOG;AAEH;IACI,WAAM;IAEN;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;;;OAIG;IACH,gBAFU,WAAW,GAAC,IAAI,CAEZ;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEe;CAClC;AAqBD;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.js

@@ -17,6 +17,7 @@ import { sampler_descriptor_pack } from "../../texture/format/sampler_descriptor
 import { WHITE_PIXEL_TEXTURE } from "../../texture/util/WHITE_PIXEL_TEXTURE.js";
 import { INDIRECT_MATERIAL_ARRAY_TYPE } from "./INDIRECT_MATERIAL_ARRAY_TYPE.js";
 import { INDIRECT_MATERIAL_STRUCT } from "./INDIRECT_MATERIAL_STRUCT.js";
+import { NEUTRAL_SURFACE } from "./NEUTRAL_SURFACE.js";
 import {
     RESIDENT_MATERIAL_TEXTURE_LAYER_SIZE,
     RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT,
@@ -109,23 +110,6 @@ class TextureInfo {
  */
 const MEDIA_TABLE_RECORDS_OFFSET = MEDIA_TABLE_STRUCT.fields.find(f => f.name === 'records').offset;
 
-/**
- * What a material that is not standard contributes to the ray passes: white, opaque, fully rough,
- * not metallic, not transmissive, not emissive — through the default textures its missing slots
- * already resolve to. Without it the fields the row is written from are absent and skipped into a
- * zeroed buffer, and an opacity of 0 is a surface the rays pass through: a terrain would stop
- * casting ray-traced shadows, and a bake would see it black. The same values a flat standard
- * material gives, which is what the terrain drew with before it had a template of its own.
- */
-const NEUTRAL_SURFACE = Object.freeze({
-    diffuse_color: Object.freeze([1, 1, 1, 1]),
-    roughness_factor: 1,
-    metallic_factor: 0,
-    transmission_factor: 0,
-    ior_factor: 1.5,
-    emissive_factor: Object.freeze([0, 0, 0]),
-});
-
 export class GPUResidentMaterialContext {
 
     /**
@@ -444,7 +428,7 @@ export class GPUResidentMaterialContext {
      * the same contract {@link GPUMaterialManager} restages by. A hit used to be final, so a factor
      * set after the first pack never reached the row. Every caller re-obtains what it needs before
      * {@link update} or {@link commit}: the scene's drawn list, the manager's materials whenever its
-     * version moves, or what a card capture traces, so the check rides on walks that already happen.
+     * version moves, or what a surface bake traces, so the check rides on walks that already happen.
      *
      * @param {ShadeMaterial} material
      * @returns {MaterialInfo}

package/src/shade/renderer/material/resident/NEUTRAL_SURFACE.d.ts

@@ -0,0 +1,17 @@
+/**
+ * What a material that is not standard contributes to the ray passes: white, opaque, fully rough,
+ * not metallic, not transmissive, not emissive — through the default textures its missing slots
+ * already resolve to. Without it the fields the row is written from are absent and skipped into a
+ * zeroed buffer, and an opacity of 0 is a surface the rays pass through: a terrain would stop
+ * casting ray-traced shadows, and a bake would see it black. The same values a flat standard
+ * material gives, which is what the terrain drew with before it had a template of its own.
+ */
+export const NEUTRAL_SURFACE: Readonly<{
+    diffuse_color: readonly number[];
+    roughness_factor: 1;
+    metallic_factor: 0;
+    transmission_factor: 0;
+    ior_factor: 1.5;
+    emissive_factor: readonly number[];
+}>;
+//# sourceMappingURL=NEUTRAL_SURFACE.d.ts.map

package/src/shade/renderer/material/resident/NEUTRAL_SURFACE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NEUTRAL_SURFACE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/NEUTRAL_SURFACE.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH;;;;;;;GAOG"}

package/src/shade/renderer/material/resident/NEUTRAL_SURFACE.js

@@ -0,0 +1,16 @@
+/**
+ * What a material that is not standard contributes to the ray passes: white, opaque, fully rough,
+ * not metallic, not transmissive, not emissive — through the default textures its missing slots
+ * already resolve to. Without it the fields the row is written from are absent and skipped into a
+ * zeroed buffer, and an opacity of 0 is a surface the rays pass through: a terrain would stop
+ * casting ray-traced shadows, and a bake would see it black. The same values a flat standard
+ * material gives, which is what the terrain drew with before it had a template of its own.
+ */
+export const NEUTRAL_SURFACE = Object.freeze({
+    diffuse_color: Object.freeze([1, 1, 1, 1]),
+    roughness_factor: 1,
+    metallic_factor: 0,
+    transmission_factor: 0,
+    ior_factor: 1.5,
+    emissive_factor: Object.freeze([0, 0, 0]),
+});

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: {