@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/rasterize/native/graph_rasterize_meshes_alpha_tested.js

@@ -1,4 +1,6 @@
 import { assert } from "../../../../core/assert.js";
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { STRUCT_DISPATCH_COMPUTE_COMMAND } from "../../gpu_primitive/indirect/STRUCT_DISPATCH_COMPUTE_COMMAND.js";
 import { STRUCT_UNINDEXED_DRAW_COMMAND } from "../../gpu_primitive/indirect/STRUCT_UNINDEXED_DRAW_COMMAND.js";
 import { BindGroupDescriptor } from "../../binding/BindGroupDescriptor.js";
 import { ShadeDrawMode } from "../../material/ShadeDrawMode.js";
@@ -20,6 +22,11 @@ import {
     RASTERIZATION_SHADER_BIND_GROUP_SCENE,
     RASTERIZATION_SHADER_BIND_GROUP_VIEW
 } from "./alpha_tested_pass_resources.js";
+import {
+    shader_visible_meshlets_copy_array,
+    shader_visible_meshlets_offset_commands,
+    shader_visible_meshlets_reserve
+} from "../visibility/shader_visible_meshlets_append.js";
 
 const DRAW_COMMAND_BYTE_SIZE = STRUCT_UNINDEXED_DRAW_COMMAND.aligned_size;
 
@@ -38,7 +45,10 @@ const DRAW_COMMAND_BYTE_SIZE = STRUCT_UNINDEXED_DRAW_COMMAND.aligned_size;
  * @param {GPUCollectionLimits} options.limits
  * @param {number[]} [options.viewport] [x,y, width, height] -1 width/height indicates that we need to disable viewport setup
  * @param {TemplatePassDescriptor} options.render_pass_descriptor the pass, with a pipeline per material template
- * @returns {{executed:boolean, depth:number, color_targets:number[]}} whether a pass was recorded, along with the depth and colour handles to carry forward. When no pass is recorded the input handles are returned unchanged.
+ * @param {number} [options.visible_meshlets] the frame's visible-meshlet table, when the pass writes its slots
+ *   ({@link RenderPassDescriptor#visible_meshlet_slots}) and only then: the meshlets are appended to it and drawn
+ *   from there
+ * @returns {{executed:boolean, depth:number, color_targets:number[], visible_meshlets:number}} whether a pass was recorded, along with the depth, colour and table handles to carry forward. When no pass is recorded the input handles are returned unchanged.
  */
 export function graph_rasterize_meshes_alpha_tested({
                                                         graph,
@@ -52,7 +62,8 @@ export function graph_rasterize_meshes_alpha_tested({
                                                         raster_color_targets,
                                                         limits,
                                                         viewport = [0, 0, -1, -1],
-                                                        render_pass_descriptor
+                                                        render_pass_descriptor,
+                                                        visible_meshlets = -1,
                                                     }) {
 
     assert.isNonNegativeInteger(buckets, 'buckets');
@@ -63,6 +74,7 @@ export function graph_rasterize_meshes_alpha_tested({
     assert.isBoolean(clear_target, 'clear_target');
 
     assert.equal(render_pass_descriptor.isTemplatePassDescriptor, true, 'render_pass_descriptor.isTemplatePassDescriptor !== true');
+    assert.equal(visible_meshlets !== -1, render_pass_descriptor.visible_meshlet_slots, 'a pipeline that writes visible-meshlet slots draws from the table, and only it does');
 
     const scene_ctx = view_ctx.scene;
 
@@ -91,6 +103,7 @@ export function graph_rasterize_meshes_alpha_tested({
             executed: false,
             depth,
             color_targets: raster_color_targets,
+            visible_meshlets,
         };
     }
 
@@ -112,11 +125,47 @@ export function graph_rasterize_meshes_alpha_tested({
 
 
         const command_buffer_draw = resources.get(data.command_buffer_draw);
-        const meshlet_buffer = resources.get(data.meshlet_buffer);
+
+        /**
+         * What the draws take their meshlets from
+         * @type {GPUBuffer}
+         */
+        let meshlet_buffer = resources.get(data.meshlet_buffer);
 
         // first prepare dispatch command for filtering
         const encoder = context.encoder;
 
+        if (data.visible_meshlets !== undefined) {
+            // the sorted meshlets go into the table, and every material's command onto their copy there
+            const table = resources.get(data.visible_meshlets);
+            const append_draw = resources.get(data.append_draw);
+            const copy_command = resources.get(data.copy_command);
+
+            shader_visible_meshlets_reserve.dispatch({
+                encoder,
+                bindings: {
+                    input: resources.get(data.meshlet_collection),
+                    visible_meshlets: table,
+                    draw: append_draw,
+                    copy: copy_command
+                },
+            });
+
+            shader_visible_meshlets_copy_array.dispatchIndirect({
+                encoder,
+                command: copy_command,
+                bindings: { draw: append_draw, input: meshlet_buffer, visible_meshlets: table },
+            });
+
+            shader_visible_meshlets_offset_commands.dispatchThreads({
+                encoder,
+                thread_count_x: material_count,
+                bindings: { draw: append_draw, commands: command_buffer_draw },
+            });
+
+            meshlet_buffer = table;
+        }
+
         const depth_texture = resources.get(data.depth);
 
         /**
@@ -140,8 +189,8 @@ export function graph_rasterize_meshes_alpha_tested({
         const partial_clear_needed = !is_viewport_unrestricted && clear_target;
 
         if (partial_clear_needed) {
-            for (let i = 0; i < color_targets.length; i++) {
-                texture_fill_rectangle(encoder, color_targets[i], viewport, render_pass_descriptor.colorAttachments[i].clearValue);
+            for (let i = 0; i < color_targets.length; i++) {
+                texture_fill_rectangle(encoder, color_targets[i], viewport, render_pass_descriptor.colorAttachments[i].clearValue);
             }
             texture_fill_rectangle(encoder, depth_texture, viewport, [render_pass_descriptor.depthStencilAttachment.depthClearValue]);
         }
@@ -250,7 +299,7 @@ export function graph_rasterize_meshes_alpha_tested({
 
     const gr_camera = graph_import_buffer(graph, view_ctx.camera.buffer.buffer);
 
-    const { meshlets, draw_commands } = graph_prepare_meshlet_draw_commands_by_material({
+    const { meshlets, draw_commands, meshlet_collection } = graph_prepare_meshlet_draw_commands_by_material({
         graph,
         materials: relevant_materials,
         bucket_id: alpha_tested_bucket_index,
@@ -269,11 +318,25 @@ export function graph_rasterize_meshes_alpha_tested({
     const pass_data = {};
     const pass = graph.add("rasterize alpha tested meshes", pass_data, execute);
 
-    // reserve buffer for indirect draw commands
-    pass_data.command_buffer_draw = pass.read(draw_commands);
-
     pass_data.meshlet_buffer = pass.read(meshlets);
 
+    if (visible_meshlets === -1) {
+        pass_data.command_buffer_draw = pass.read(draw_commands);
+    } else {
+        // the commands are moved onto the table's slots in place
+        pass_data.command_buffer_draw = pass.write(draw_commands);
+        pass_data.meshlet_collection = pass.read(meshlet_collection);
+        pass_data.visible_meshlets = pass.write(visible_meshlets);
+        pass_data.append_draw = pass.create("visible meshlets append", BufferResourceDescriptor.from(
+            STRUCT_UNINDEXED_DRAW_COMMAND.size,
+            GPUBufferUsage.STORAGE
+        ));
+        pass_data.copy_command = pass.create("visible meshlets copy command", BufferResourceDescriptor.from(
+            STRUCT_DISPATCH_COMPUTE_COMMAND.size,
+            GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT
+        ));
+    }
+
     // TODO move texture resource import outside
     let viz_depth = depth;
 
@@ -286,5 +349,6 @@ export function graph_rasterize_meshes_alpha_tested({
         executed: true,
         depth: pass_data.depth,
         color_targets: pass_data.out_color_targets,
+        visible_meshlets: pass_data.visible_meshlets ?? -1,
     };
 }

package/src/shade/renderer/rasterize/native/viz/shader_vertex.js

@@ -4,14 +4,14 @@ import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
 import { MESH_TRIANGLE_REFERENCE_STRUCT } from "../../../geometry/meshlet/MESH_TRIANGLE_REFERENCE_STRUCT.js";
 import { chunk_rasterize_triangle } from "../chunk_rasterize_triangle.js";
 import { rasterization_shader_resources } from "../rasterization_shader_resources.js";
+import { VISIBILITY_TRIANGLE_BITS } from "../../visibility/VISIBILITY_BUFFER.js";
 
 const body = CodeChunk.from(
     //language=WGSL
     `
 struct VertexOutput{
     @builtin(position) position: vec4f,
-    @location(0) @interpolate(flat) m_mesh:u32,
-    @location(1) @interpolate(flat) m_triangle:u32,
+    @location(0) @interpolate(flat) m_visibility: u32,
 }
 
 @vertex
@@ -35,8 +35,8 @@ fn main(
 
     output.position = projected_vertex;
 
-    output.m_mesh = triangle_def.mesh;
-    output.m_triangle = triangle_def.index ;
+    // the draw takes its meshlets from the frame's visible-meshlet table, so the instance is the slot
+    output.m_visibility = (meshlet_index << ${VISIBILITY_TRIANGLE_BITS}u) | (triangle_def.index & ${2 ** VISIBILITY_TRIANGLE_BITS - 1}u);
 
     return output;
 

package/src/shade/renderer/rasterize/native/viz/viz_rasterization_alpha_tested_pass_descriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"viz_rasterization_alpha_tested_pass_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/viz/viz_rasterization_alpha_tested_pass_descriptor.js"],"names":[],"mappings":"AA0LA;;;;GAIG;AACH,6DAFU,sBAAsB,CAqC7B;uCA5LoC,iCAAiC"}
+{"version":3,"file":"viz_rasterization_alpha_tested_pass_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/viz/viz_rasterization_alpha_tested_pass_descriptor.js"],"names":[],"mappings":"AAiLA;;;;GAIG;AACH,6DAFU,sBAAsB,CAiC7B;uCAlLoC,iCAAiC"}

package/src/shade/renderer/rasterize/native/viz/viz_rasterization_alpha_tested_pass_descriptor.js

@@ -11,9 +11,6 @@ import {
     chunk_triangle_list_reverse_winding
 } from "../../../shader/chunk/geometry/triangle/chunk_triangle_list_reverse_winding.js";
 import { chunk_view_mip_bias } from "../../../view/chunk_view_mip_bias.js";
-import {
-    chunk_encode_meshlet_element
-} from "../../../shader/chunk/geometry/meshlet/chunk_encode_meshlet_element.js";
 import {
     chunk_read_meshlet_attribute_u32
 } from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_attribute_u32.js";
@@ -38,7 +35,12 @@ import {
 } from "../alpha_tested_pass_resources.js";
 import { TemplatePassDescriptor } from "../../TemplatePassDescriptor.js";
 import { rasterization_primitive_state } from "../rasterization_primitive_state.js";
-import { VIZ_BUFFER_INVALID_MESH_VALUE } from "./VIZ_BUFFER_INVALID_MESH_VALUE.js";
+import {
+    VISIBILITY_FORMAT,
+    VISIBILITY_NONE,
+    VISIBILITY_TRIANGLE_BITS,
+    VISIBLE_MESHLETS_ARRAY_OFFSET
+} from "../../visibility/VISIBILITY_BUFFER.js";
 
 /**
  * The harness around a template's `material_opacity`: the hashed threshold and the noise that feeds
@@ -52,19 +54,14 @@ import { VIZ_BUFFER_INVALID_MESH_VALUE } from "./VIZ_BUFFER_INVALID_MESH_VALUE.j
 const fragment_body = CodeChunk.from(
 //language=WGSL
     `
-struct VizBufferOutput{
-    @location(0) m_triangle : u32,
-    @location(1) m_mesh : u32,
-}
 
 @fragment
 fn main(
     @builtin(position) coord : vec4<f32>,
-    @location(0) @interpolate(flat) m_mesh:u32,
-    @location(1) @interpolate(flat) m_triangle:u32,
-    @location(2) uv_jittered:vec2<f32>,
-    @location(3) position_world: vec3<f32>,
-) -> VizBufferOutput {
+    @location(0) @interpolate(flat) m_visibility: u32,
+    @location(1) uv_jittered:vec2<f32>,
+    @location(2) position_world: vec3<f32>,
+) -> @location(0) u32 {
 
     // Note that we use jittered UVs directly, the compensation happens inside TAAU itself.
     let uv = uv_jittered;
@@ -94,18 +91,12 @@ fn main(
         discard;
     }
 
-    var result:VizBufferOutput;
-
-    //decode meshlet payload
-    result.m_triangle = m_triangle ;
-    result.m_mesh = m_mesh ;
-
-    return result;
+    return m_visibility;
 }
     `, [
         chunk_material_opacity_contract,
         chunk_transparency_hashed_alpha_threshold,
-        chunk_spatio_temporal_noise_r2_64,
+        chunk_spatio_temporal_noise_r2_64,
         chunk_view_mip_bias,
     ]
 );
@@ -117,10 +108,9 @@ const shader_vertex = ShaderDescriptor.from({
         `
 struct VertexOutput{
     @builtin(position) position: vec4f,
-    @location(0) @interpolate(flat) m_mesh: u32,
-    @location(1) @interpolate(flat) m_triangle: u32,
-    @location(2) uv: vec2f,
-    @location(3) position_world: vec3f,
+    @location(0) @interpolate(flat) m_visibility: u32,
+    @location(1) uv: vec2f,
+    @location(2) position_world: vec3f,
 }
 
 @vertex
@@ -142,7 +132,6 @@ fn main(
         return VertexOutput(); // discard vertex outside of meshlet bounds
     }
     
-    let triangle_index = encode_meshlet_element(meshlet_id, vertex_draw_index / 3u);
 
     let mesh = scene_read_mesh(&scene_database, mesh_id);
     let node = scene_read_node(&scene_database, mesh.node);
@@ -164,8 +153,11 @@ fn main(
     output.position_world = position_world.xyz / position_world.w;
     output.position = camera.view_projection_matrix * position_world;
 
-    output.m_mesh = mesh_id;
-    output.m_triangle = triangle_index;
+    // the draws bind the frame's visible-meshlet table as a bare array of definitions, where slot s is
+    // at s + VISIBLE_MESHLETS_ARRAY_OFFSET
+    let slot = input_index - ${VISIBLE_MESHLETS_ARRAY_OFFSET}u;
+
+    output.m_visibility = (slot << ${VISIBILITY_TRIANGLE_BITS}u) | (vertex_draw_index / 3u);
     output.uv = meshlet_vertex.uv;
     
     return output;
@@ -173,7 +165,6 @@ fn main(
     `, [
             chunk_read_meshlet_vertex,
             chunk_read_meshlet_attribute_u32,
-            chunk_encode_meshlet_element,
             chunk_read_meshlet_vertex_by_draw_index,
             chunk_scene_database_access,
             chunk_triangle_winding_is_reversed,
@@ -213,11 +204,7 @@ export const viz_rasterization_alpha_tested_pass_descriptor = new TemplatePassDe
             },
             targets: [
                 {
-                    // triangle ID
-                    format: "r32uint",
-                }, {
-                    // Mesh ID
-                    format: "r32uint",
+                    format: VISIBILITY_FORMAT,
                 }
             ]
         },
@@ -227,15 +214,11 @@ export const viz_rasterization_alpha_tested_pass_descriptor = new TemplatePassDe
 });
 
 viz_rasterization_alpha_tested_pass_descriptor.colorAttachments = [
-    // TRIANGLE ID
     RenderPassColorAttachmentDescriptor.from({
-        clearValue: [0, 0, 0, 0],
+        clearValue: [VISIBILITY_NONE, 0, 0, 0],
     }),
-    // MESH ID
-    RenderPassColorAttachmentDescriptor.from({
-        clearValue: [VIZ_BUFFER_INVALID_MESH_VALUE, 1, 1, 1],
-    })
 ];
+viz_rasterization_alpha_tested_pass_descriptor.visible_meshlet_slots = true;
 
 /**
  * Clear depth to 0 for reverse Z technique

package/src/shade/renderer/rasterize/native/viz/viz_rasterization_opaque_pass_descriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"viz_rasterization_opaque_pass_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/viz/viz_rasterization_opaque_pass_descriptor.js"],"names":[],"mappings":"AA2DA,4EAAmF;qCAxD9C,8CAA8C"}
+{"version":3,"file":"viz_rasterization_opaque_pass_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/viz/viz_rasterization_opaque_pass_descriptor.js"],"names":[],"mappings":"AA0CA,4EAAmF;qCAvC9C,8CAA8C"}

package/src/shade/renderer/rasterize/native/viz/viz_rasterization_opaque_pass_descriptor.js

@@ -1,77 +1,56 @@
-import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { DEPTH_BACKGROUND_VALUE } from "../../../depth/DEPTH_BACKGROUND_VALUE.js";
-import { RenderPassColorAttachmentDescriptor } from "../../../shader/pass/RenderPassColorAttachmentDescriptor.js";
-import { RenderPassDescriptor } from "../../../shader/pass/RenderPassDescriptor.js";
-import { DEPTH_STENCIL_STATE_STANDARD } from "../../DEPTH_STENCIL_STATE_STANDARD.js";
-import { rasterization_primitive_state } from "../rasterization_primitive_state.js";
-import { rasterization_shader_resources } from "../rasterization_shader_resources.js";
-import { shader_vertex } from "./shader_vertex.js";
-import { VIZ_BUFFER_INVALID_MESH_VALUE } from "./VIZ_BUFFER_INVALID_MESH_VALUE.js";
-
-//language=WGSL
-const shader_fragment_visibility_buffer = `
-struct VizBufferOutput{
-    @location(0) m_triangle : u32,
-    @location(1) m_mesh : u32,
-}
-
-@fragment
-fn main(
-    @builtin(position) coord : vec4<f32>,
-    @location(0) @interpolate(flat) m_mesh:u32,
-    @location(1) @interpolate(flat) m_triangle:u32,
-) -> VizBufferOutput {
-    var result:VizBufferOutput;
-
-    //decode meshlet payload
-    result.m_triangle = m_triangle ;
-    result.m_mesh = m_mesh ;
-
-    return result;
-}
-`;
-
-const gpu_rasterization_render_pipeline_descriptor = RenderPipelineDescriptor.from({
-    label: "Rasterize to Visibility Buffer / opaque",
-    layout: rasterization_shader_resources.generatePipelineLayout(GPUShaderStage.VERTEX),
-    vertex: {
-        module: {
-            code: shader_vertex.source
-        }
-    },
-    fragment: {
-        module: {
-            code: shader_fragment_visibility_buffer
-        },
-        targets: [
-            {
-                // triangle ID
-                format: "r32uint",
-            }, {
-                // Mesh ID
-                format: "r32uint",
-            }
-        ]
-    },
-    depthStencil: DEPTH_STENCIL_STATE_STANDARD,
-    primitive: rasterization_primitive_state
-});
-
-export const viz_rasterization_opaque_pass_descriptor = new RenderPassDescriptor();
-viz_rasterization_opaque_pass_descriptor.pipeline = gpu_rasterization_render_pipeline_descriptor;
-viz_rasterization_opaque_pass_descriptor.resources = rasterization_shader_resources;
-viz_rasterization_opaque_pass_descriptor.colorAttachments = [
-    // TRIANGLE ID
-    RenderPassColorAttachmentDescriptor.from({
-        clearValue: [0, 0, 0, 0],
-    }),
-    // MESH ID
-    RenderPassColorAttachmentDescriptor.from({
-        clearValue: [VIZ_BUFFER_INVALID_MESH_VALUE, 1, 1, 1],
-    })
-];
-
-/**
- * Clear depth to 0 for reverse Z technique
- */
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { DEPTH_BACKGROUND_VALUE } from "../../../depth/DEPTH_BACKGROUND_VALUE.js";
+import { RenderPassColorAttachmentDescriptor } from "../../../shader/pass/RenderPassColorAttachmentDescriptor.js";
+import { RenderPassDescriptor } from "../../../shader/pass/RenderPassDescriptor.js";
+import { DEPTH_STENCIL_STATE_STANDARD } from "../../DEPTH_STENCIL_STATE_STANDARD.js";
+import { rasterization_primitive_state } from "../rasterization_primitive_state.js";
+import { rasterization_shader_resources } from "../rasterization_shader_resources.js";
+import { shader_vertex } from "./shader_vertex.js";
+import { VISIBILITY_FORMAT, VISIBILITY_NONE } from "../../visibility/VISIBILITY_BUFFER.js";
+
+//language=WGSL
+const shader_fragment_visibility_buffer = `
+@fragment
+fn main(
+    @location(0) @interpolate(flat) m_visibility: u32,
+) -> @location(0) u32 {
+    return m_visibility;
+}
+`;
+
+const gpu_rasterization_render_pipeline_descriptor = RenderPipelineDescriptor.from({
+    label: "Rasterize to Visibility Buffer / opaque",
+    layout: rasterization_shader_resources.generatePipelineLayout(GPUShaderStage.VERTEX),
+    vertex: {
+        module: {
+            code: shader_vertex.source
+        }
+    },
+    fragment: {
+        module: {
+            code: shader_fragment_visibility_buffer
+        },
+        targets: [
+            {
+                format: VISIBILITY_FORMAT,
+            }
+        ]
+    },
+    depthStencil: DEPTH_STENCIL_STATE_STANDARD,
+    primitive: rasterization_primitive_state
+});
+
+export const viz_rasterization_opaque_pass_descriptor = new RenderPassDescriptor();
+viz_rasterization_opaque_pass_descriptor.pipeline = gpu_rasterization_render_pipeline_descriptor;
+viz_rasterization_opaque_pass_descriptor.resources = rasterization_shader_resources;
+viz_rasterization_opaque_pass_descriptor.colorAttachments = [
+    RenderPassColorAttachmentDescriptor.from({
+        clearValue: [VISIBILITY_NONE, 0, 0, 0],
+    }),
+];
+viz_rasterization_opaque_pass_descriptor.visible_meshlet_slots = true;
+
+/**
+ * Clear depth to 0 for reverse Z technique
+ */
 viz_rasterization_opaque_pass_descriptor.depthStencilAttachment.depthClearValue = DEPTH_BACKGROUND_VALUE;

package/src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.d.ts

@@ -25,13 +25,15 @@ export function enquire_rasterize_partial_opaque_pipelines(enquiry: PipelineEnqu
  * @param {Set<number>} active_buckets IDs of buckets that have any materials that are active.
  * @param {number[]} [viewport] optional viewport definition, if not provided, will use the entire render target. Useful for drawing multiple views into the same render target.
  * @param {Readonly<Record<number, GPUCullMode>>} [cull_policy] side→cullMode mapping; defaults to {@link CullPolicy.Standard}
- * @returns {{instances_maybe:number, meshlets_maybe:number, depth:number, color_targets:number[]}} the "maybe visible" sets, and the depth and colour handles produced by the rasterization — cleared whether or not any bucket drew
+ * @param {number} [visible_meshlets] the frame's visible-meshlet table, when the pass writes its slots
+ * @returns {{instances_maybe:number, meshlets_maybe:number, depth:number, color_targets:number[], visible_meshlets:number}} the "maybe visible" sets, the depth and colour handles produced by the rasterization — cleared whether or not any bucket drew — and the table after it (-1 without one)
  */
-export function graph_rasterize_partial_opaque({ graph, buckets, view, render_pass_descriptor, limits, depth, raster_color_targets, hzb, viewport, active_buckets, cull_policy, }: FrameGraph): {
+export function graph_rasterize_partial_opaque({ graph, buckets, view, render_pass_descriptor, limits, depth, raster_color_targets, hzb, viewport, active_buckets, cull_policy, visible_meshlets, }: FrameGraph): {
     instances_maybe: number;
     meshlets_maybe: number;
     depth: number;
     color_targets: number[];
+    visible_meshlets: number;
 };
 export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type RenderPassDescriptor = import("../../shader/pass/RenderPassDescriptor.js").RenderPassDescriptor;

package/src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_partial_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js"],"names":[],"mappings":"AA8BA;;;GAGG;AAEH;;;;;;;GAOG;AACH,oEAJW,eAAe,0BACf,oBAAoB,eACpB,SAAS,OAAO,MAAM,cAAc,CAAC,QAY/C;AAED;;;;;;;;;;;;;;;GAeG;AACH,gMAFa;IAAC,eAAe,EAAC,MAAM,CAAC;IAAC,cAAc,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CA0NjG;8BAhQY,OAAO,6CAA6C,EAAE,eAAe;mCACrE,OAAO,2CAA2C,EAAE,oBAAoB"}
+{"version":3,"file":"graph_rasterize_partial_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js"],"names":[],"mappings":"AA8BA;;;GAGG;AAEH;;;;;;;GAOG;AACH,oEAJW,eAAe,0BACf,oBAAoB,eACpB,SAAS,OAAO,MAAM,cAAc,CAAC,QAY/C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kNAFa;IAAC,eAAe,EAAC,MAAM,CAAC;IAAC,cAAc,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAC;IAAC,gBAAgB,EAAC,MAAM,CAAA;CAAC,CA6N1H;8BApQY,OAAO,6CAA6C,EAAE,eAAe;mCACrE,OAAO,2CAA2C,EAAE,oBAAoB"}

package/src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js

@@ -67,7 +67,8 @@ export function enquire_rasterize_partial_opaque_pipelines(enquiry, render_pass_
  * @param {Set<number>} active_buckets IDs of buckets that have any materials that are active.
  * @param {number[]} [viewport] optional viewport definition, if not provided, will use the entire render target. Useful for drawing multiple views into the same render target.
  * @param {Readonly<Record<number, GPUCullMode>>} [cull_policy] side→cullMode mapping; defaults to {@link CullPolicy.Standard}
- * @returns {{instances_maybe:number, meshlets_maybe:number, depth:number, color_targets:number[]}} the "maybe visible" sets, and the depth and colour handles produced by the rasterization — cleared whether or not any bucket drew
+ * @param {number} [visible_meshlets] the frame's visible-meshlet table, when the pass writes its slots
+ * @returns {{instances_maybe:number, meshlets_maybe:number, depth:number, color_targets:number[], visible_meshlets:number}} the "maybe visible" sets, the depth and colour handles produced by the rasterization — cleared whether or not any bucket drew — and the table after it (-1 without one)
  */
 export function graph_rasterize_partial_opaque({
                                                    graph,
@@ -81,6 +82,7 @@ export function graph_rasterize_partial_opaque({
                                                    viewport,
                                                    active_buckets,
                                                    cull_policy = CullPolicy.Standard,
+                                                   visible_meshlets = -1,
                                                }) {
 
     assert.defined(graph, 'graph');
@@ -240,7 +242,7 @@ export function graph_rasterize_partial_opaque({
         gr_meshlets_maybe = pass_data_meshlets_1.out_meshlets_maybe = pass_meshlets_1.write(gr_meshlets_maybe);
 
         // ----------
-        [viz_depth, raster_color_targets] = graph_meshlets_rasterize_by_bucket({
+        [viz_depth, raster_color_targets, visible_meshlets] = graph_meshlets_rasterize_by_bucket({
             graph,
             view,
             input_meshlets: pass_data_meshlets_1.out_meshlets_positive,
@@ -252,6 +254,7 @@ export function graph_rasterize_partial_opaque({
             cull_policy,
             viewport,
             limits,
+            visible_meshlets,
         });
 
         is_first_draw = false;
@@ -284,5 +287,6 @@ export function graph_rasterize_partial_opaque({
         meshlets_maybe: gr_meshlets_maybe,
         depth: viz_depth,
         color_targets: raster_color_targets,
+        visible_meshlets,
     };
 }

package/src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.d.ts

@@ -26,11 +26,13 @@ export function enquire_rasterize_remaining_opaque_pipelines(enquiry: PipelineEn
  * @param {RenderPassDescriptor} render_pass_descriptor
  * @param {number[]} [viewport] optional viewport definition
  * @param {Readonly<Record<number, GPUCullMode>>} [cull_policy] side→cullMode mapping; defaults to {@link CullPolicy.Standard}
- * @returns {{depth:number, color_targets:number[]}} the depth and colour handles produced by the rasterization
+ * @param {number} [visible_meshlets] the frame's visible-meshlet table, when the pass writes its slots
+ * @returns {{depth:number, color_targets:number[], visible_meshlets:number}} the depth and colour handles produced by the rasterization, and the table after it (-1 without one)
  */
-export function graph_rasterize_remaining_opaque({ graph, limits, instances_maybe, meshlets_maybe, active_buckets, camera, view, depth, raster_color_targets, hzb, render_pass_descriptor, viewport, cull_policy, }: FrameGraph): {
+export function graph_rasterize_remaining_opaque({ graph, limits, instances_maybe, meshlets_maybe, active_buckets, camera, view, depth, raster_color_targets, hzb, render_pass_descriptor, viewport, cull_policy, visible_meshlets, }: FrameGraph): {
     depth: number;
     color_targets: number[];
+    visible_meshlets: number;
 };
 export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type RenderPassDescriptor = import("../../shader/pass/RenderPassDescriptor.js").RenderPassDescriptor;

package/src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_remaining_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js"],"names":[],"mappings":"AAmBA;;;GAGG;AAEH;;;;;;GAMG;AACH,sEAJW,eAAe,0BACf,oBAAoB,eACpB,SAAS,OAAO,MAAM,cAAc,CAAC,QAO/C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,kOAFa;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAqFlD;8BAvHY,OAAO,6CAA6C,EAAE,eAAe;mCACrE,OAAO,2CAA2C,EAAE,oBAAoB"}
+{"version":3,"file":"graph_rasterize_remaining_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js"],"names":[],"mappings":"AAmBA;;;GAGG;AAEH;;;;;;GAMG;AACH,sEAJW,eAAe,0BACf,oBAAoB,eACpB,SAAS,OAAO,MAAM,cAAc,CAAC,QAO/C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,oPAFa;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAC;IAAC,gBAAgB,EAAC,MAAM,CAAA;CAAC,CAwF3E;8BA3HY,OAAO,6CAA6C,EAAE,eAAe;mCACrE,OAAO,2CAA2C,EAAE,oBAAoB"}

package/src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js

@@ -52,7 +52,8 @@ export function enquire_rasterize_remaining_opaque_pipelines(enquiry, render_pas
  * @param {RenderPassDescriptor} render_pass_descriptor
  * @param {number[]} [viewport] optional viewport definition
  * @param {Readonly<Record<number, GPUCullMode>>} [cull_policy] side→cullMode mapping; defaults to {@link CullPolicy.Standard}
- * @returns {{depth:number, color_targets:number[]}} the depth and colour handles produced by the rasterization
+ * @param {number} [visible_meshlets] the frame's visible-meshlet table, when the pass writes its slots
+ * @returns {{depth:number, color_targets:number[], visible_meshlets:number}} the depth and colour handles produced by the rasterization, and the table after it (-1 without one)
  */
 export function graph_rasterize_remaining_opaque({
                                                      graph,
@@ -68,6 +69,7 @@ export function graph_rasterize_remaining_opaque({
                                                      render_pass_descriptor,
                                                      viewport,
                                                      cull_policy = CullPolicy.Standard,
+                                                     visible_meshlets = -1,
                                                  }) {
 
     let gr_depth_texture = depth;
@@ -118,7 +120,7 @@ export function graph_rasterize_remaining_opaque({
     const opaque = Array.from(rasterization_opaque_buckets(active_buckets));
 
     if (opaque.length > 0) {
-        [gr_depth_texture, raster_color_targets] = graph_meshlets_rasterize_by_bucket({
+        [gr_depth_texture, raster_color_targets, visible_meshlets] = graph_meshlets_rasterize_by_bucket({
             graph,
             view,
             input_meshlets: gr_live_meshlets,
@@ -130,11 +132,13 @@ export function graph_rasterize_remaining_opaque({
             cull_policy,
             viewport,
             limits,
+            visible_meshlets,
         });
     }
 
     return {
         depth: gr_depth_texture,
         color_targets: raster_color_targets,
+        visible_meshlets,
     }
 }

package/src/shade/renderer/rasterize/standard/graph_rasterize_scene.d.ts

@@ -22,8 +22,10 @@ export function enquire_rasterize_scene_pipelines(enquiry: PipelineEnquiry, opaq
  * @param {FrameGraph} options.graph
  * @param {RasterizationJob} options.job
  * @param {GPUCollectionLimits} options.limits
- * @returns {{buckets: number, depth: number, color_targets: number[]}} the render buckets buffer,
- *   and the depth and colour targets as this pipeline left them
+ * @returns {{buckets: number, depth: number, color_targets: number[], visible_meshlets: number}} the render
+ *   buckets buffer, the depth and colour targets as this pipeline left them, and — when the job's passes write
+ *   visible-meshlet slots, as the visibility raster's do — the frame's visible-meshlet table, which resolves
+ *   them (-1 otherwise)
  */
 export function graph_rasterize_scene({ graph, job, limits, }: {
     graph: FrameGraph;
@@ -33,6 +35,7 @@ export function graph_rasterize_scene({ graph, job, limits, }: {
     buckets: number;
     depth: number;
     color_targets: number[];
+    visible_meshlets: number;
 };
 export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type RenderPassDescriptor = import("../../shader/pass/RenderPassDescriptor.js").RenderPassDescriptor;

package/src/shade/renderer/rasterize/standard/graph_rasterize_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_scene.js"],"names":[],"mappings":"AAqBA;;;GAGG;AAEH;;;;;;;;;GASG;AACH,2DAJW,eAAe,eACf,oBAAoB,eACpB,SAAS,OAAO,MAAM,cAAc,CAAC,QAQ/C;AAED;;;;;;;;;;;GAWG;AACH;IAN+B,KAAK;IACC,GAAG;IACA,MAAM;IACjC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAC,CAmNrE;8BAlPY,OAAO,6CAA6C,EAAE,eAAe;mCACrE,OAAO,2CAA2C,EAAE,oBAAoB"}
+{"version":3,"file":"graph_rasterize_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_scene.js"],"names":[],"mappings":"AAuBA;;;GAGG;AAEH;;;;;;;;;GASG;AACH,2DAJW,eAAe,eACf,oBAAoB,eACpB,SAAS,OAAO,MAAM,cAAc,CAAC,QAQ/C;AAED;;;;;;;;;;;;;GAaG;AACH;IAR+B,KAAK;IACC,GAAG;IACA,MAAM;IACjC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAC,CA0P/F;8BAzRY,OAAO,6CAA6C,EAAE,eAAe;mCACrE,OAAO,2CAA2C,EAAE,oBAAoB"}