@woosh/meep-engine 3.61.3 → 3.62.0

package/src/shade/renderer/rasterize/TemplatePassDescriptor.js

@@ -108,6 +108,7 @@ export class TemplatePassDescriptor extends RenderPassDescriptor {
             r.resources = origin.resources;
             r.colorAttachments = origin.colorAttachments;
             r.depthStencilAttachment = origin.depthStencilAttachment;
+            r.visible_meshlet_slots = origin.visible_meshlet_slots;
 
             origin.#variants.set(set, r);
         }

package/src/shade/renderer/rasterize/bucket/graph_meshlets_rasterize_by_bucket.d.ts

@@ -38,9 +38,11 @@ export function enquire_meshlets_rasterize_by_bucket_pipelines(enquiry: Pipeline
  * @param {Readonly<Record<number, GPUCullMode>>} options.cull_policy
  * @param {number[]} [options.viewport]
  * @param {GPUCollectionLimits} options.limits
- * @returns {[number, number[]]} depth and colour handles, as {@link graph_meshlets_rasterize}
+ * @param {number} [options.visible_meshlets] the frame's visible-meshlet table, which every draw appends to,
+ *   as {@link graph_meshlets_rasterize}
+ * @returns {[number, number[], number]} depth, colour and table handles, as {@link graph_meshlets_rasterize}
  */
-export function graph_meshlets_rasterize_by_bucket({ graph, view, input_meshlets, buckets, depth, color_targets, pass_descriptor, clear_targets, cull_policy, viewport, limits, }: {
+export function graph_meshlets_rasterize_by_bucket({ graph, view, input_meshlets, buckets, depth, color_targets, pass_descriptor, clear_targets, cull_policy, viewport, limits, visible_meshlets, }: {
     graph: FrameGraph;
     view: GPUViewContext;
     input_meshlets: number;
@@ -56,7 +58,8 @@ export function graph_meshlets_rasterize_by_bucket({ graph, view, input_meshlets
     cull_policy: Readonly<Record<number, GPUCullMode>>;
     viewport?: number[];
     limits: GPUCollectionLimits;
-}): [number, number[]];
+    visible_meshlets?: number;
+}): [number, number[], number];
 export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type RenderPassDescriptor = import("../../shader/pass/RenderPassDescriptor.js").RenderPassDescriptor;
 //# sourceMappingURL=graph_meshlets_rasterize_by_bucket.d.ts.map

package/src/shade/renderer/rasterize/bucket/graph_meshlets_rasterize_by_bucket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_meshlets_rasterize_by_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/graph_meshlets_rasterize_by_bucket.js"],"names":[],"mappings":"AAaA;;;GAGG;AAEH;;;;;;;;;GASG;AACH,wEAJW,eAAe,mBACf,oBAAoB,eACpB,SAAS,OAAO,MAAM,cAAc,CAAC,QAS/C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAd+B,KAAK;IACD,IAAI;IACZ,cAAc,EAA9B,MAAM;IAC0D,OAAO,EAAvE;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,EAAE;IAEtC,KAAK,EAArB,MAAM;IACY,aAAa,EAA/B,MAAM,EAAE;IACsB,eAAe,EAA7C,oBAAoB;IACH,aAAa,EAA9B,OAAO;IACwC,WAAW,EAA1D,SAAS,OAAO,MAAM,cAAc,CAAC;IAClB,QAAQ,GAA3B,MAAM,EAAE;IACqB,MAAM;IACjC,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAmE9B;8BAnHY,OAAO,6CAA6C,EAAE,eAAe;mCACrE,OAAO,2CAA2C,EAAE,oBAAoB"}
+{"version":3,"file":"graph_meshlets_rasterize_by_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/graph_meshlets_rasterize_by_bucket.js"],"names":[],"mappings":"AAaA;;;GAGG;AAEH;;;;;;;;;GASG;AACH,wEAJW,eAAe,mBACf,oBAAoB,eACpB,SAAS,OAAO,MAAM,cAAc,CAAC,QAS/C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAhB+B,KAAK;IACD,IAAI;IACZ,cAAc,EAA9B,MAAM;IAC0D,OAAO,EAAvE;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,EAAE;IAEtC,KAAK,EAArB,MAAM;IACY,aAAa,EAA/B,MAAM,EAAE;IACsB,eAAe,EAA7C,oBAAoB;IACH,aAAa,EAA9B,OAAO;IACwC,WAAW,EAA1D,SAAS,OAAO,MAAM,cAAc,CAAC;IAClB,QAAQ,GAA3B,MAAM,EAAE;IACqB,MAAM;IAClB,gBAAgB,GAAjC,MAAM;IAEJ,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,CAsEtC;8BAxHY,OAAO,6CAA6C,EAAE,eAAe;mCACrE,OAAO,2CAA2C,EAAE,oBAAoB"}

package/src/shade/renderer/rasterize/bucket/graph_meshlets_rasterize_by_bucket.js

@@ -60,7 +60,9 @@ export function enquire_meshlets_rasterize_by_bucket_pipelines(enquiry, pass_des
  * @param {Readonly<Record<number, GPUCullMode>>} options.cull_policy
  * @param {number[]} [options.viewport]
  * @param {GPUCollectionLimits} options.limits
- * @returns {[number, number[]]} depth and colour handles, as {@link graph_meshlets_rasterize}
+ * @param {number} [options.visible_meshlets] the frame's visible-meshlet table, which every draw appends to,
+ *   as {@link graph_meshlets_rasterize}
+ * @returns {[number, number[], number]} depth, colour and table handles, as {@link graph_meshlets_rasterize}
  */
 export function graph_meshlets_rasterize_by_bucket({
                                                        graph,
@@ -74,6 +76,7 @@ export function graph_meshlets_rasterize_by_bucket({
                                                        cull_policy,
                                                        viewport,
                                                        limits,
+                                                       visible_meshlets = -1,
                                                    }) {
     assert.isArray(buckets, 'buckets');
     assert.greaterThanOrEqual(buckets.length, 1, 'buckets.length');
@@ -91,6 +94,7 @@ export function graph_meshlets_rasterize_by_bucket({
             clear_targets,
             primitive_state: construct_primitive_state(draw_mode, side, cull_policy),
             viewport,
+            visible_meshlets,
         });
     }
 
@@ -111,7 +115,7 @@ export function graph_meshlets_rasterize_by_bucket({
             limits,
         });
 
-        [depth, color_targets] = graph_meshlets_rasterize({
+        [depth, color_targets, visible_meshlets] = graph_meshlets_rasterize({
             graph,
             view,
             input_meshlets: meshlets,
@@ -121,10 +125,11 @@ export function graph_meshlets_rasterize_by_bucket({
             clear_targets: clear,
             primitive_state: construct_primitive_state(draw_mode, side, cull_policy),
             viewport,
+            visible_meshlets,
         });
 
         clear = false;
     }
 
-    return [depth, color_targets];
+    return [depth, color_targets, visible_meshlets];
 }

package/src/shade/renderer/rasterize/expand/GPUCollectionLimits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUCollectionLimits.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/expand/GPUCollectionLimits.js"],"names":[],"mappings":"AAwBA;;GAEG;AACH;IAyBI;;;OAGG;IACH,+BAuBC;IAxCD;;;OAGG;IACH,uCAEC;IAoCD;;;;OAIG;IACH,gBAHW,2BAA2B,GAC1B,MAAM,CAMjB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAHW,2BAA2B,SAC3B,MAAM,QAQhB;IAED;;;;OAIG;IACH,0BAHW,2BAA2B,GACzB,MAAM,CAyBlB;IA+BD,gBAEC;IAED;;;;;;;OAOG;IACH,gBAHW,sBAAsB,WACtB,kBAAkB,iBAkB5B;;CAEJ;qCArMY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,oCAAoC,EAAE,kBAAkB;0CANlC,yCAAyC;4CACvC,kCAAkC"}
+{"version":3,"file":"GPUCollectionLimits.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/expand/GPUCollectionLimits.js"],"names":[],"mappings":"AA0BA;;GAEG;AACH;IAyBI;;;OAGG;IACH,+BAwBC;IAzCD;;;OAGG;IACH,uCAEC;IAqCD;;;;OAIG;IACH,gBAHW,2BAA2B,GAC1B,MAAM,CAMjB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAHW,2BAA2B,SAC3B,MAAM,QAQhB;IAED;;;;OAIG;IACH,0BAHW,2BAA2B,GACzB,MAAM,CAyBlB;IA+BD,gBAEC;IAED;;;;;;;OAOG;IACH,gBAHW,sBAAsB,WACtB,kBAAkB,iBAkB5B;;CAEJ;qCAxMY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,oCAAoC,EAAE,kBAAkB;0CANlC,yCAAyC;4CACvC,kCAAkC"}

package/src/shade/renderer/rasterize/expand/GPUCollectionLimits.js

@@ -20,6 +20,8 @@ const ELEMENT_SIZES = {
     [RasterizationCollectionType.ObjectPropertyReference]: Uint32Array.BYTES_PER_ELEMENT * 2,
     // LightClusterEntries: one light id, u32
     [RasterizationCollectionType.LightClusterEntries]: Uint32Array.BYTES_PER_ELEMENT,
+    // MeshletDefinition, as Meshlets
+    [RasterizationCollectionType.VisibleMeshlets]: Uint32Array.BYTES_PER_ELEMENT * 2,
 }
 
 /**
@@ -67,6 +69,7 @@ export class GPUCollectionLimits {
         // prime stats to avoid pops
         this.#stats.setGlobalMax(RasterizationCollectionType.Meshes, 1e4);
         this.#stats.setGlobalMax(RasterizationCollectionType.Meshlets, 2e5);
+        this.#stats.setGlobalMax(RasterizationCollectionType.VisibleMeshlets, 2e5);
         this.#stats.setGlobalMax(RasterizationCollectionType.ObjectPropertyReference, 1024);
         // primed for each cluster grid by graph_assign_clsuters
         this.#stats.setGlobalMax(RasterizationCollectionType.LightClusterEntries, 0);

package/src/shade/renderer/rasterize/expand/RasterizationCollectionType.d.ts

@@ -9,5 +9,6 @@ export namespace RasterizationCollectionType {
     let Meshlets: number;
     let ObjectPropertyReference: number;
     let LightClusterEntries: number;
+    let VisibleMeshlets: number;
 }
 //# sourceMappingURL=RasterizationCollectionType.d.ts.map

package/src/shade/renderer/rasterize/expand/RasterizationCollectionType.js

@@ -19,4 +19,9 @@ export const RasterizationCollectionType = {
      * culled light's box of cells — see {@link CLUSTER_LIGHT_BOUND}.
      */
     LightClusterEntries: 3,
+    /**
+     * The frame's visible-meshlet table: every meshlet the view's raster draws into the visibility
+     * buffer, at the slot its pixels name — see `graph_rasterize_scene`.
+     */
+    VisibleMeshlets: 4,
 };

package/src/shade/renderer/rasterize/expand/graph_meshlets_rasterize.d.ts

@@ -20,9 +20,13 @@ export function enquire_meshlets_rasterize_pipelines(enquiry: PipelineEnquiry, p
  * @param {number[]} [options.viewport] drives {@link GPURenderPassEncoder.setViewport}. Format: [x, y, width, height]
  * @param {PrimitiveState} [options.primitive_state]
  * @param {boolean} [options.clear_targets]
- * @return {[depth:number, color:number[]]}
+ * @param {number} [options.visible_meshlets] the frame's visible-meshlet table, when `pass_descriptor` writes
+ *   its slots ({@link RenderPassDescriptor#visible_meshlet_slots}) and only then: the draw appends its
+ *   meshlets to the table and draws them from there, so each instance is the slot of its meshlet
+ * @return {[depth:number, color:number[], visible_meshlets:number]} the targets as the draw left them, and the
+ *   table with its meshlets appended (-1 without one)
  */
-export function graph_meshlets_rasterize({ graph, view, input_meshlets, depth, pass_descriptor, color_targets, viewport, primitive_state, clear_targets, }: {
+export function graph_meshlets_rasterize({ graph, view, input_meshlets, depth, pass_descriptor, color_targets, viewport, primitive_state, clear_targets, visible_meshlets, }: {
     graph: FrameGraph;
     view: GPUViewContext;
     input_meshlets: number;
@@ -32,7 +36,8 @@ export function graph_meshlets_rasterize({ graph, view, input_meshlets, depth, p
     viewport?: number[];
     primitive_state?: PrimitiveState;
     clear_targets?: boolean;
-}): [depth: number, color: number[]];
+    visible_meshlets?: number;
+}): [depth: number, color: number[], visible_meshlets: number];
 export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type RenderPassDescriptor = import("../../shader/pass/RenderPassDescriptor.js").RenderPassDescriptor;
 export type PrimitiveState = import("../../../descriptor/pipeline/render/PrimitiveState.js").PrimitiveState;

package/src/shade/renderer/rasterize/expand/graph_meshlets_rasterize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_meshlets_rasterize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/expand/graph_meshlets_rasterize.js"],"names":[],"mappings":"AAmBA;;;;;;;;GAQG;AACH,8DAJW,eAAe,mBACf,oBAAoB,mBACpB,cAAc,QAKxB;AAED;;;;;;;;;;;;;GAaG;AACH;IAX+B,KAAK;IACD,IAAI;IACZ,cAAc,EAA9B,MAAM;IACU,KAAK,EAArB,MAAM;IACwB,eAAe,EAA7C,oBAAoB;IACD,aAAa,GAAhC,MAAM,EAAE;IACW,QAAQ,GAA3B,MAAM,EAAE;IACiB,eAAe,GAAxC,cAAc;IACI,aAAa,GAA/B,OAAO;IACN,CAAC,KAAK,EAAC,MAAM,EAAE,KAAK,EAAC,MAAM,EAAE,CAAC,CA2IzC;8BA5KY,OAAO,6CAA6C,EAAE,eAAe;mCACrE,OAAO,2CAA2C,EAAE,oBAAoB;6BACxE,OAAO,uDAAuD,EAAE,cAAc"}
+{"version":3,"file":"graph_meshlets_rasterize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/expand/graph_meshlets_rasterize.js"],"names":[],"mappings":"AAwBA;;;;;;;;GAQG;AACH,8DAJW,eAAe,mBACf,oBAAoB,mBACpB,cAAc,QAUxB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH;IAf+B,KAAK;IACD,IAAI;IACZ,cAAc,EAA9B,MAAM;IACU,KAAK,EAArB,MAAM;IACwB,eAAe,EAA7C,oBAAoB;IACD,aAAa,GAAhC,MAAM,EAAE;IACW,QAAQ,GAA3B,MAAM,EAAE;IACiB,eAAe,GAAxC,cAAc;IACI,aAAa,GAA/B,OAAO;IACU,gBAAgB,GAAjC,MAAM;IAGL,CAAC,KAAK,EAAC,MAAM,EAAE,KAAK,EAAC,MAAM,EAAE,EAAE,gBAAgB,EAAC,MAAM,CAAC,CA+KlE;8BAxNY,OAAO,6CAA6C,EAAE,eAAe;mCACrE,OAAO,2CAA2C,EAAE,oBAAoB;6BACxE,OAAO,uDAAuD,EAAE,cAAc"}

package/src/shade/renderer/rasterize/expand/graph_meshlets_rasterize.js

@@ -8,6 +8,11 @@ import {
 } from "../../gpu_primitive/indirect/build_indirect_draw_command.js";
 import { rp_rewrite_for_primitive_state } from "../../../device/pipeline/rp_rewrite_for_primitive_state.js";
 import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../../geometry/meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
+import { STRUCT_DISPATCH_COMPUTE_COMMAND } from "../../gpu_primitive/indirect/STRUCT_DISPATCH_COMPUTE_COMMAND.js";
+import {
+    shader_visible_meshlets_copy,
+    shader_visible_meshlets_reserve
+} from "../visibility/shader_visible_meshlets_append.js";
 
 /**
  * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
@@ -27,7 +32,12 @@ const DRAW_COMMAND_PATTERN = `${GEOMETRY_MESHLET_TRIANGLE_LIMIT * 3}, input, 0,
  * @param {PrimitiveState} primitive_state
  */
 export function enquire_meshlets_rasterize_pipelines(enquiry, pass_descriptor, primitive_state) {
-    enquiry.compute.push(indirect_draw_command_pipeline(enquiry.device, DRAW_COMMAND_PATTERN));
+    if (pass_descriptor.visible_meshlet_slots) {
+        enquiry.compute.push(shader_visible_meshlets_reserve.pipeline);
+        enquiry.compute.push(shader_visible_meshlets_copy.pipeline);
+    } else {
+        enquiry.compute.push(indirect_draw_command_pipeline(enquiry.device, DRAW_COMMAND_PATTERN));
+    }
     enquiry.render.push(rp_rewrite_for_primitive_state(pass_descriptor.pipeline, primitive_state));
 }
 
@@ -43,7 +53,11 @@ export function enquire_meshlets_rasterize_pipelines(enquiry, pass_descriptor, p
  * @param {number[]} [options.viewport] drives {@link GPURenderPassEncoder.setViewport}. Format: [x, y, width, height]
  * @param {PrimitiveState} [options.primitive_state]
  * @param {boolean} [options.clear_targets]
- * @return {[depth:number, color:number[]]}
+ * @param {number} [options.visible_meshlets] the frame's visible-meshlet table, when `pass_descriptor` writes
+ *   its slots ({@link RenderPassDescriptor#visible_meshlet_slots}) and only then: the draw appends its
+ *   meshlets to the table and draws them from there, so each instance is the slot of its meshlet
+ * @return {[depth:number, color:number[], visible_meshlets:number]} the targets as the draw left them, and the
+ *   table with its meshlets appended (-1 without one)
  */
 export function graph_meshlets_rasterize({
                                              graph,
@@ -55,6 +69,7 @@ export function graph_meshlets_rasterize({
                                              viewport = [0, 0, -1, -1],
                                              primitive_state,
                                              clear_targets = true,
+                                             visible_meshlets = -1,
                                          }) {
     assert.equal(pass_descriptor.isRenderPassDescriptor, true, "pass_descriptor must be a RenderPassDescriptor");
     assert.isBoolean(clear_targets, 'clear_targets');
@@ -62,6 +77,7 @@ export function graph_meshlets_rasterize({
     assert.isNonNegativeInteger(depth, 'depth');
     assert.isArray(color_targets, 'color_targets');
     assert.equal(view.isGPUViewContext, true, "view must be a GPUViewContext");
+    assert.equal(visible_meshlets !== -1, pass_descriptor.visible_meshlet_slots, 'a pipeline that writes visible-meshlet slots draws from the table, and only it does');
 
     /**
      *
@@ -77,7 +93,31 @@ export function graph_meshlets_rasterize({
         const encoder = context.encoder;
         const device = encoder.device;
 
-        build_indirect_draw_command(device, DRAW_COMMAND_PATTERN, encoder, input_meshlets, command);
+        /**
+         * What the draw takes its meshlets from
+         * @type {GPUBuffer}
+         */
+        let draw_meshlets = input_meshlets;
+
+        if (data.visible_meshlets === undefined) {
+            build_indirect_draw_command(device, DRAW_COMMAND_PATTERN, encoder, input_meshlets, command);
+        } else {
+            const table = resources.get(data.visible_meshlets);
+            const copy_command = resources.get(data.copy_command);
+
+            shader_visible_meshlets_reserve.dispatch({
+                encoder,
+                bindings: { input: input_meshlets, visible_meshlets: table, draw: command, copy: copy_command },
+            });
+
+            shader_visible_meshlets_copy.dispatchIndirect({
+                encoder,
+                command: copy_command,
+                bindings: { draw: command, input: input_meshlets, visible_meshlets: table },
+            });
+
+            draw_meshlets = table;
+        }
 
         const scene = view.scene;
         const geometry_context = scene.geometries;
@@ -142,7 +182,7 @@ export function graph_meshlets_rasterize({
                 meshlet_metadata: scene.geometries.meshlets.buffer_metadata,
                 geometries: geometry_context.buffer_metadata,
                 materials: scene.materials.metadata_table.buffer,
-                meshlets: input_meshlets,
+                meshlets: draw_meshlets,
             }
         });
 
@@ -174,12 +214,21 @@ export function graph_meshlets_rasterize({
         GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT
     ));
     data.input_meshlets = pass.read(input_meshlets);
+
+    if (visible_meshlets !== -1) {
+        data.visible_meshlets = pass.write(visible_meshlets);
+        data.copy_command = pass.create("visible meshlets copy command", BufferResourceDescriptor.from(
+            STRUCT_DISPATCH_COMPUTE_COMMAND.size,
+            GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT
+        ));
+    }
     data.out_texture_depth = pass.write(depth);
 
     data.out_color_targets = color_targets.map(pass.write, pass);
 
     return [
         data.out_texture_depth,
-        data.out_color_targets
+        data.out_color_targets,
+        data.visible_meshlets ?? -1,
     ];
 }

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts

@@ -48,6 +48,7 @@ export type AVBOITSideChannel = {
         color_texture: number;
         depth_texture: number;
         normal_texture: number;
+        pbr_texture: number;
         hzb_texture: number;
         environment_texture: number;
         light_cluster_parameters: number;

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,eAAqB,EAAE,OAAO,6CAA6C,EAAE,eAAe,CAAC;QAC7F,MAAY,EAAE,OAAO,iEAAiE,EAAE,iBAAiB,CAAC;KACvG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAMtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAW9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAChG,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,eAAqB,EAAE,OAAO,6CAA6C,EAAE,eAAe,CAAC;QAC7F,MAAY,EAAE,OAAO,iEAAiE,EAAE,iBAAiB,CAAC;KACvG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAMtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAW9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js

@@ -36,7 +36,7 @@
  * @typedef {object} AVBOITSideChannel
  * @property {(args: {graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,
  *     view_ctx: import("../../../view/GPUViewContext.js").GPUViewContext, camera: number,
- *     color_texture: number, depth_texture: number, normal_texture: number,
+ *     color_texture: number, depth_texture: number, normal_texture: number, pbr_texture: number,
  *     hzb_texture: number, environment_texture: number,
  *     light_cluster_parameters: number, light_cluster_lookup: number, light_cluster_data: number,
  *     shadowmap_atlas: number,

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.d.ts

@@ -171,7 +171,7 @@ export function avboit_create_accumulators(pass: FramePassBuilder, resolution: A
  *   sources of transparent fragments; the MBOIT orchestrator ignores them
  * @returns {number} resource ID of the composited color texture
  */
-export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, normal_texture, hzb_texture, environment_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, shader_switches, probes, avboit, side_channels, }: {
+export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, normal_texture, pbr_texture, hzb_texture, environment_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, shader_switches, probes, avboit, side_channels, }: {
     graph: FrameGraph;
     buckets: number;
     view_ctx: GPUViewContext;

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CA4M7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IA3B+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGC,eAAe,GAAzC,eAAe;IAGsF,MAAM,EAA3G,OAAO,iEAAiE,EAAE,iBAAiB;IAGlE,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAqTlB;+BAx9B8B,qBAAqB;gCAIpB,6CAA6C"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CA4M7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IA3B+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGC,eAAe,GAAzC,eAAe;IAGsF,MAAM,EAA3G,OAAO,iEAAiE,EAAE,iBAAiB;IAGlE,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAsTlB;+BAz9B8B,qBAAqB;gCAIpB,6CAA6C"}

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js

@@ -721,6 +721,7 @@ export function graph_rasterize_meshes_transparent_avboit({
                                                               depth_texture,
                                                               color_texture,
                                                               normal_texture,
+                                                              pbr_texture,
                                                               hzb_texture,
                                                               environment_texture,
                                                               limits,
@@ -829,7 +830,7 @@ export function graph_rasterize_meshes_transparent_avboit({
     let background_color = color_texture;
     for (const channel of preparers) {
         const prepared = channel.avboit_prepare({ graph, view_ctx, camera: gr_camera, color_texture,
-            depth_texture, normal_texture, hzb_texture: gr_hzb, environment_texture, light_cluster_parameters,
+            depth_texture, normal_texture, pbr_texture, hzb_texture: gr_hzb, environment_texture, light_cluster_parameters,
             light_cluster_lookup, light_cluster_data, shadowmap_atlas, shader_switches, probes });
         if (prepared?.background_color !== undefined) {
             assert.isNonNegativeInteger(prepared.background_color, 'prepared.background_color');

package/src/shade/renderer/rasterize/native/graph_rasterize_meshes_alpha_tested.d.ts

@@ -13,9 +13,12 @@
  * @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, buckets, view_ctx, clear_target, side, cull_policy, depth, hzb, raster_color_targets, limits, viewport, render_pass_descriptor }: {
+export function graph_rasterize_meshes_alpha_tested({ graph, buckets, view_ctx, clear_target, side, cull_policy, depth, hzb, raster_color_targets, limits, viewport, render_pass_descriptor, visible_meshlets, }: {
     graph: FrameGraph;
     buckets: number;
     view_ctx: GPUViewContext;
@@ -28,10 +31,12 @@ export function graph_rasterize_meshes_alpha_tested({ graph, buckets, view_ctx,
     limits: GPUCollectionLimits;
     viewport?: number[];
     render_pass_descriptor: TemplatePassDescriptor;
+    visible_meshlets?: number;
 }): {
     executed: boolean;
     depth: number;
     color_targets: number[];
+    visible_meshlets: number;
 };
 import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
 //# sourceMappingURL=graph_rasterize_meshes_alpha_tested.d.ts.map

package/src/shade/renderer/rasterize/native/graph_rasterize_meshes_alpha_tested.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_alpha_tested.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/native/graph_rasterize_meshes_alpha_tested.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;GAgBG;AACH;IAd+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,YAAY,GAA9B,OAAO;IACiB,IAAI,GAA5B,aAAa;IACmC,WAAW,GAA3D,SAAS,OAAO,MAAM,cAAc,CAAC;IACrB,KAAK,EAArB,MAAM;IACU,GAAG,EAAnB,MAAM;IACY,oBAAoB,EAAtC,MAAM,EAAE;IACqB,MAAM;IAChB,QAAQ,GAA3B,MAAM,EAAE;IACwB,sBAAsB;IACpD;IAAC,QAAQ,EAAC,OAAO,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAyPpE;8BA7R6B,iCAAiC"}
+{"version":3,"file":"graph_rasterize_meshes_alpha_tested.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/native/graph_rasterize_meshes_alpha_tested.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAjB+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,YAAY,GAA9B,OAAO;IACiB,IAAI,GAA5B,aAAa;IACmC,WAAW,GAA3D,SAAS,OAAO,MAAM,cAAc,CAAC;IACrB,KAAK,EAArB,MAAM;IACU,GAAG,EAAnB,MAAM;IACY,oBAAoB,EAAtC,MAAM,EAAE;IACqB,MAAM;IAChB,QAAQ,GAA3B,MAAM,EAAE;IACwB,sBAAsB;IACrC,gBAAgB,GAAjC,MAAM;IAGJ;IAAC,QAAQ,EAAC,OAAO,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAC;IAAC,gBAAgB,EAAC,MAAM,CAAA;CAAC,CA+S7F;8BA3V6B,iCAAiC"}

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