@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js

@@ -9,8 +9,9 @@ import {
     MESHLET_METADATA_STRUCT
 } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
 import {
-    VIZ_BUFFER_INVALID_MESH_VALUE
-} from "../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+    chunk_visibility_decode,
+    VISIBLE_MESHLETS_RESOURCE
+} from "../../rasterize/visibility/chunk_visibility_decode.js";
 import {
     chunk_scene_database_access
 } from "../../scene/chunk_scene_database_access.js";
@@ -44,8 +45,8 @@ const resources = new ShaderResourceSetDescriptor();
 
 resources.createGroup()
     .addTexture("tDepth")
-    .addTexture("tVizMesh", "uint")
-    .addTexture("tVizTriangle", "uint")
+    .addTexture("tVisibility", "uint")
+    .add(VISIBLE_MESHLETS_RESOURCE)
     .addUniform("mReprojectionRotation", mat4x4f)
     // Un-jittered current-frame inverse view-projection and
     // un-jittered previous-frame view-projection. TAA wants
@@ -78,7 +79,6 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-const VIZ_INVALID: u32 = ${VIZ_BUFFER_INVALID_MESH_VALUE}u;
 const PREV_POS_OFFSET_INVALID: u32 = 0xFFFFFFFFu;
 
 fn read_prev_position(base: u32, vertex_index: u32) -> vec3<f32> {
@@ -97,14 +97,14 @@ fn main(
 
     let cur_px = coord.xy;
     let texel = vec2<u32>(cur_px);
-    let mesh_id = textureLoad(tVizMesh, texel, 0).r;
+    let visibility_word = textureLoad(tVisibility, texel, 0).r;
 
     // ── Background: rotation-only reprojection ──────────────────
     //
-    // Visibility-buffer clears leave mesh_id == VIZ_INVALID on sky
+    // Visibility-buffer clears leave VISIBILITY_NONE on sky
     // pixels, where reverse-Z depth is always 0.0. Passing 0.0
     // directly avoids a tDepth textureLoad on every background pixel.
-    if mesh_id == VIZ_INVALID {
+    if visibility_word == VISIBILITY_NONE {
         let position_previous = v3_matrix4_project(
             vec3<f32>(cur_px, 0.0),
             mReprojectionRotation
@@ -123,16 +123,16 @@ fn main(
     let cur_world_h = mInvViewProjCurrent * vec4<f32>(cur_ndc, 1.0);
     let cur_world = cur_world_h.xyz / cur_world_h.w;
 
-    let mesh = scene_read_mesh(&scene_database, mesh_id);
+    let visibility_texel = visibility_decode(visibility_word);
+
+    let mesh = scene_read_mesh(&scene_database, visibility_texel.mesh);
     let node = scene_read_node(&scene_database, mesh.node);
 
     // ── Skinned vs static fork ─────────────────────────────────
     //
-    // viz_triangle encodes (meshlet_id, triangle_local) via
-    // encode_meshlet_element — upper 24 bits meshlet, lower 8 bits
-    // triangle-within-meshlet. Look up the per-meshlet
-    // prev-position offset; sentinel means "not a skinned clone,
-    // use rigid per-object math".
+    // The visibility word names the meshlet and the triangle within
+    // it. Look up the per-meshlet prev-position offset; sentinel
+    // means "not a skinned clone, use rigid per-object math".
     //
     // The per-vertex skinning path reads prev_position_offsets /
     // prev_positions, which only hold valid data when a skinned mesh is
@@ -140,17 +140,15 @@ fn main(
     // bindings (the scene_database buffer) and reading them would feed
     // garbage offsets into the skinned branch — a non-sentinel word
     // there sends a static triangle down the per-vertex path and
-    // fabricates a constant phantom velocity. Gate both the tVizTriangle
-    // textureLoad and the offset buffer read on skinning_active so
-    // non-skinned scenes skip the full-screen tVizTriangle fetch and
-    // every pixel takes the rigid per-object path.
+    // fabricates a constant phantom velocity. Gate the offset buffer
+    // read on skinning_active so every pixel of a non-skinned scene
+    // takes the rigid per-object path.
     var meshlet_id = 0u;
     var tri_local = 0u;
     var prev_pos_base = PREV_POS_OFFSET_INVALID;
     if skinning_active.value != 0u {
-        let triangle_packed = textureLoad(tVizTriangle, texel, 0).r;
-        meshlet_id = (triangle_packed >> 8u) & 0x00FFFFFFu;
-        tri_local = triangle_packed & 0xFFu;
+        meshlet_id = visibility_texel.meshlet;
+        tri_local = visibility_texel.triangle;
         prev_pos_base = prev_position_offsets[meshlet_id];
     }
 
@@ -253,6 +251,7 @@ fn main(
         chunk_read_meshlet_resolved_index,
         chunk_read_meshlet_vertex_position,
         MESHLET_METADATA_STRUCT.declaration_chunk,
+        chunk_visibility_decode,
     ]
 );
 
@@ -285,7 +284,7 @@ export function enquire_per_object_velocity_pipelines(enquiry) {
 /**
  * Per-pixel motion-vector pass with three branches:
  *
- *  1. **Background** (no rasterized geometry, `viz_mesh == INVALID`)
+ *  1. **Background** (no rasterized geometry, `VISIBILITY_NONE`)
  *     — rotation-only reprojection of the current pixel through the
  *     camera's frame-over-frame rotation delta. Suitable for skybox
  *     / infinite background.
@@ -317,8 +316,8 @@ export function enquire_per_object_velocity_pipelines(enquiry) {
  * @param {object} args
  * @param {FrameGraph} args.graph
  * @param {number} args.texture_depth
- * @param {number} args.texture_viz_mesh
- * @param {number} args.texture_viz_triangle
+ * @param {number} args.texture_visibility the visibility buffer
+ * @param {number} args.buffer_visible_meshlets the frame's visible-meshlet table, which resolves it
  * @param {number} args.buffer_scene_database
  * @param {number} args.buffer_meshlet_metadata
  * @param {number} args.buffer_meshlet_data
@@ -329,14 +328,13 @@ export function enquire_per_object_velocity_pipelines(enquiry) {
  *      placeholders and the shader forces the rigid path.
  * @param {number[]} args.resolution
  * @param {GPUViewContext} args.view
- * @param {boolean} [args.enable_mipmap]
  * @returns {number} FrameGraph handle to the velocity texture (rg16float)
  */
 export function graph_add_per_object_velocity({
                                                   graph,
                                                   texture_depth,
-                                                  texture_viz_mesh,
-                                                  texture_viz_triangle,
+                                                  texture_visibility,
+                                                  buffer_visible_meshlets,
                                                   buffer_scene_database,
                                                   buffer_meshlet_metadata,
                                                   buffer_meshlet_data,
@@ -345,13 +343,12 @@ export function graph_add_per_object_velocity({
                                                   skinning_active,
                                                   resolution,
                                                   view,
-                                                  enable_mipmap = false,
                                               }) {
 
     assert.defined(view, 'view');
     assert.isNonNegativeInteger(texture_depth, 'texture_depth');
-    assert.isNonNegativeInteger(texture_viz_mesh, 'texture_viz_mesh');
-    assert.isNonNegativeInteger(texture_viz_triangle, 'texture_viz_triangle');
+    assert.isNonNegativeInteger(texture_visibility, 'texture_visibility');
+    assert.isNonNegativeInteger(buffer_visible_meshlets, 'buffer_visible_meshlets');
     assert.isNonNegativeInteger(buffer_scene_database, 'buffer_scene_database');
     assert.isNonNegativeInteger(buffer_meshlet_metadata, 'buffer_meshlet_metadata');
     assert.isNonNegativeInteger(buffer_meshlet_data, 'buffer_meshlet_data');
@@ -395,8 +392,8 @@ export function graph_add_per_object_velocity({
         shader,
         inputs: {
             tDepth: texture_depth,
-            tVizMesh: texture_viz_mesh,
-            tVizTriangle: texture_viz_triangle,
+            tVisibility: texture_visibility,
+            visible_meshlets: buffer_visible_meshlets,
             mReprojectionRotation: reprojection_matrix_pixels_rotation,
             mInvViewProjCurrent: scratch_unjit_inv_view_proj_curr_f32,
             mViewProjPrevious: scratch_unjit_view_proj_prev_f32,
@@ -408,6 +405,5 @@ export function graph_add_per_object_velocity({
             prev_positions: buffer_prev_positions,
         },
         output_resolution: resolution,
-        output_mipmaps: enable_mipmap,
     })[0];
 }

package/src/shade/renderer/rasterize/TemplatePassDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TemplatePassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/TemplatePassDescriptor.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IA0CI;;;;OAIG;IACH,mBAJW,MAAM,gBACG,qBAAqB,QAAE,eAAe,KAAG,wBAAwB,EAWpF;IA3CD;;OAEG;IACH,gCAEC;IAwCD;;;;;;;OAOG;IACH,aAHW,eAAe,GACb,sBAAsB,CAwBlC;IAED;;;;;;;OAOG;IACH,gHAEC;IAED;;;OAGG;IACH,cAEC;IAED;;OAEG;IACH,qBAEC;IAED;;;OAGG;IACH,uCAHW,qBAAqB,GACnB,wBAAwB,CAYpC;IAED;;;;;OAKG;IACH,kCALW,qBAAqB,YACrB,qBAAqB,6CAsC/B;IAGL;;;OAGG;IACH,mCAFU,OAAO,CAEwC;;CANxD;uCAlMY,OAAO,8DAA8D,EAAE,wBAAwB;uCAC/F,OAAO,uDAAuD,EAAE,wBAAwB;oCACxF,OAAO,gDAAgD,EAAE,qBAAqB;oCAC9E,OAAO,+CAA+C,EAAE,qBAAqB;qCANrD,wCAAwC;gCAD7C,uCAAuC"}
+{"version":3,"file":"TemplatePassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/TemplatePassDescriptor.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IA0CI;;;;OAIG;IACH,mBAJW,MAAM,gBACG,qBAAqB,QAAE,eAAe,KAAG,wBAAwB,EAWpF;IA3CD;;OAEG;IACH,gCAEC;IAwCD;;;;;;;OAOG;IACH,aAHW,eAAe,GACb,sBAAsB,CAyBlC;IAED;;;;;;;OAOG;IACH,gHAEC;IAED;;;OAGG;IACH,cAEC;IAED;;OAEG;IACH,qBAEC;IAED;;;OAGG;IACH,uCAHW,qBAAqB,GACnB,wBAAwB,CAYpC;IAED;;;;;OAKG;IACH,kCALW,qBAAqB,YACrB,qBAAqB,6CAsC/B;IAGL;;;OAGG;IACH,mCAFU,OAAO,CAEwC;;CANxD;uCAnMY,OAAO,8DAA8D,EAAE,wBAAwB;uCAC/F,OAAO,uDAAuD,EAAE,wBAAwB;oCACxF,OAAO,gDAAgD,EAAE,qBAAqB;oCAC9E,OAAO,+CAA+C,EAAE,qBAAqB;qCANrD,wCAAwC;gCAD7C,uCAAuC"}

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