@woosh/meep-engine 3.61.3 → 3.62.0

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

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

@@ -3,6 +3,7 @@ import { graph_build_hzb } from "../../hiz/graph_build_hzb.js";
 import { HierarchicalZBuffer } from "../../hiz/HierarchicalZBuffer.js";
 import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
 import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
+import { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
 import { graph_import_texture } from "../../shader/graph/graph_import_texture.js";
 import { graph_record_stat } from "../../util/graph_record_stat.js";
 import { enquire_mesh_frustum_cull_pipelines, graph_mesh_frustum_cull } from "../compute/graph_mesh_frustum_cull.js";
@@ -12,6 +13,7 @@ import {
     graph_meshes_classify_buckets
 } from "../expand/bucket/mesh/graph_meshes_classify_buckets.js";
 import { RasterizationCollectionType } from "../expand/RasterizationCollectionType.js";
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { graph_rasterize_meshes_alpha_tested } from "../native/graph_rasterize_meshes_alpha_tested.js";
 import { enquire_rasterize_partial_opaque_pipelines, graph_rasterize_partial_opaque } from "./graph_rasterize_partial_opaque.js";
 import {
@@ -51,8 +53,10 @@ export function enquire_rasterize_scene_pipelines(enquiry, opaque_pass, cull_pol
  * @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,
@@ -101,6 +105,28 @@ export function graph_rasterize_scene({
         raster_color_targets[i] = graph_import_texture(graph, texture, `out_color/${i}`);
     }
 
+    /*
+     Every draw of a pass that writes visible-meshlet slots appends its meshlets to one table for the frame
+     and draws them from there, so the slot a pixel holds names its meshlet for every later reader. Sized as
+     the collections are, by what the frames before asked for, and never smaller than a meshlet collection:
+     any one list drawn into it can be that long. The table's own stat is the limits' last column, whose
+     growth is set back whenever an earlier column grows, while the collection's tracks the lists'.
+    */
+    assert.equal(job.alpha_tested_pass === undefined || job.alpha_tested_pass.visible_meshlet_slots === job.opaque_pass.visible_meshlet_slots, true, 'both passes of a job write visible-meshlet slots, or neither does');
+
+    let gr_visible_meshlets = -1;
+
+    if (job.opaque_pass.visible_meshlet_slots) {
+        gr_visible_meshlets = graph_create_buffer(graph, "visible meshlets", BufferResourceDescriptor.from(
+            Math.max(
+                limits.compute_buffer_size(RasterizationCollectionType.VisibleMeshlets),
+                limits.compute_buffer_size(RasterizationCollectionType.Meshlets),
+            ),
+            GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            0, 16 // clear count
+        ));
+    }
+
     const gr_culled_meshes = graph_mesh_frustum_cull({
         graph,
         camera: gr_camera_current,
@@ -124,6 +150,7 @@ export function graph_rasterize_scene({
         meshlets_maybe: gr_meshlet_maybe,
         depth: gr_depth_opaque_partial,
         color_targets: gr_color_opaque_partial,
+        visible_meshlets: gr_visible_meshlets_partial,
     } = graph_rasterize_partial_opaque({
         graph,
         buckets: gr_render_buckets,
@@ -137,11 +164,13 @@ export function graph_rasterize_scene({
         viewport,
         active_buckets,
         cull_policy: job.cull_policy,
+        visible_meshlets: gr_visible_meshlets,
     });
 
 
     gr_texture_depth = gr_depth_opaque_partial;
     raster_color_targets = gr_color_opaque_partial;
+    gr_visible_meshlets = gr_visible_meshlets_partial;
 
     // build HZB of "likely visible" meshlets
     gr_texture_hzb = graph_build_hzb({
@@ -155,6 +184,7 @@ export function graph_rasterize_scene({
     const {
         depth: gr_depth_opaque_full,
         color_targets: gr_color_opaque_full,
+        visible_meshlets: gr_visible_meshlets_full,
     } = graph_rasterize_remaining_opaque({
         graph,
         limits,
@@ -169,10 +199,12 @@ export function graph_rasterize_scene({
         render_pass_descriptor: job.opaque_pass,
         viewport,
         cull_policy: job.cull_policy,
+        visible_meshlets: gr_visible_meshlets,
     });
 
     gr_texture_depth = gr_depth_opaque_full;
     raster_color_targets = gr_color_opaque_full;
+    gr_visible_meshlets = gr_visible_meshlets_full;
 
     // HZB of full opaque
     gr_texture_hzb = graph_build_hzb({
@@ -209,10 +241,12 @@ export function graph_rasterize_scene({
             raster_color_targets,
             depth: gr_texture_depth,
             hzb: gr_texture_hzb,
+            visible_meshlets: gr_visible_meshlets,
         });
 
         gr_texture_depth = alpha_tested_front.depth;
         raster_color_targets = alpha_tested_front.color_targets;
+        gr_visible_meshlets = alpha_tested_front.visible_meshlets;
 
         const alpha_tested_double = graph_rasterize_meshes_alpha_tested({
             graph,
@@ -228,10 +262,12 @@ export function graph_rasterize_scene({
             raster_color_targets,
             depth: gr_texture_depth,
             hzb: gr_texture_hzb,
+            visible_meshlets: gr_visible_meshlets,
         });
 
         gr_texture_depth = alpha_tested_double.depth;
         raster_color_targets = alpha_tested_double.color_targets;
+        gr_visible_meshlets = alpha_tested_double.visible_meshlets;
 
         if (alpha_tested_front.executed || alpha_tested_double.executed) {
 
@@ -246,6 +282,10 @@ export function graph_rasterize_scene({
         }
     }
 
+    if (gr_visible_meshlets !== -1) {
+        graph_record_stat(graph, limits.stats, RasterizationCollectionType.VisibleMeshlets, gr_visible_meshlets);
+    }
+
     graph.pop_scope();
 
     /*
@@ -261,5 +301,6 @@ export function graph_rasterize_scene({
         buckets: gr_render_buckets,
         depth: gr_texture_depth,
         color_targets: raster_color_targets,
+        visible_meshlets: gr_visible_meshlets,
     };
 }

package/src/shade/renderer/rasterize/visibility/VISIBILITY_BUFFER.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The visibility buffer's format: one `u32` a pixel, `slot << VISIBILITY_TRIANGLE_BITS | triangle`. `slot` is
+ * the pixel's meshlet's place in the frame's visible-meshlet table, which says the meshlet and the mesh row
+ * it was drawn for (`chunk_visibility_decode`); `triangle` is the triangle within that meshlet.
+ *
+ * @type {GPUTextureFormat}
+ */
+export const VISIBILITY_FORMAT: GPUTextureFormat;
+/**
+ * Bits of a visibility word that hold the triangle within its meshlet, below the slot.
+ *
+ * @type {number}
+ */
+export const VISIBILITY_TRIANGLE_BITS: number;
+/**
+ * How many slots the visible-meshlet table can hold: every value the bits above the triangle reach, less
+ * the last, which {@link VISIBILITY_NONE} takes.
+ *
+ * @type {number}
+ */
+export const VISIBLE_MESHLET_SLOT_LIMIT: number;
+/**
+ * What a pixel no surface covers holds, and what the visibility buffer is cleared to: the first word of the
+ * slot past every slot the table can hold. A 32-bit float holds it exactly, as a clear value has to be —
+ * `RenderPassColorAttachmentDescriptor` keeps one in a `Float32Array`, where every bit set would round up
+ * to 2^32.
+ *
+ * @type {number}
+ */
+export const VISIBILITY_NONE: number;
+/**
+ * Where the table's elements start, counted in meshlet definitions from the start of its buffer. The table
+ * is a meshlet collection, a count before the elements; a pass that binds the whole buffer as a bare array
+ * of definitions — as the alpha-tested raster binds its lists — finds slot `s` at `s` plus this.
+ *
+ * @type {number}
+ */
+export const VISIBLE_MESHLETS_ARRAY_OFFSET: number;
+//# sourceMappingURL=VISIBILITY_BUFFER.d.ts.map

package/src/shade/renderer/rasterize/visibility/VISIBILITY_BUFFER.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VISIBILITY_BUFFER.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/visibility/VISIBILITY_BUFFER.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,iDAA2C;AAE3C;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;;;GAKG;AACH,yCAFU,MAAM,CAEmE;AAEnF;;;;;;;GAOG;AACH,8BAFU,MAAM,CAE0E;AAE1F;;;;;;GAMG;AACH,4CAFU,MAAM,CAE+G"}