@woosh/meep-engine 3.32.0 → 3.34.0

package/src/shade/renderer/rasterize/fast/graph_gather_meshes_from_buckets.js

@@ -0,0 +1,102 @@
+import { assert } from "../../../../core/assert.js";
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import {
+    build_indirect_compute_dispatch_command,
+    INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
+} from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
+import { RasterizationCollectionType } from "../expand/RasterizationCollectionType.js";
+import { shader_gather_bucket } from "../bucket/shader_gather_bucket.js";
+
+/**
+ * Several buckets' mesh indices out of a bucket-sorted mesh buffer, into one flat
+ * {@link COLLECTION_U32_STRUCT_READ} buffer, end to end in bucket order.
+ *
+ * What lets the fast path expand and cut a view once rather than once per opaque bucket
+ * (CUT_PLAN_2026_09_14 §7 6b): the opaque buckets are not neighbours in the sorted buffer — the
+ * transparency mode is the low bits of a bucket id — so they cannot be read out as one range.
+ *
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {number} options.buckets bucket-sorted meshes resource ID
+ * @param {number[]} options.bucket_ids the buckets to gather, ascending
+ * @param {GPUCollectionLimits} options.limits
+ * @returns {number} resource ID of the gathered mesh list
+ */
+export function graph_gather_meshes_from_buckets({
+                                                     graph,
+                                                     buckets,
+                                                     bucket_ids,
+                                                     limits,
+                                                 }) {
+    assert.isArray(bucket_ids, 'bucket_ids');
+
+    let gathered = 0;
+
+    for (let i = 0; i < bucket_ids.length; i++) {
+        const bucket_id = bucket_ids[i];
+
+        assert.isNonNegativeInteger(bucket_id, 'bucket_id');
+        assert.lessThan(bucket_id, 32, 'bucket_id');
+
+        // the count the last dispatch writes is the total only if the last is the highest
+        assert.ok(i === 0 || bucket_ids[i - 1] < bucket_id, 'bucket_ids must be ascending');
+
+        gathered |= 1 << bucket_id;
+    }
+
+    gathered >>>= 0;
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+        const encoder = context.encoder;
+
+        const buckets = resources.get(data.buckets);
+        const output = resources.get(data.output);
+
+        for (let i = 0; i < bucket_ids.length; i++) {
+            const bucket_id = bucket_ids[i];
+            const command = resources.get(data.commands[i]);
+
+            build_indirect_compute_dispatch_command(
+                COMPUTE_SHADER_DEFAULT_GROUP_SIZE,
+                encoder,
+                buckets,
+                // the bucketed buffer header consists of pairs of u32 values (count,offset)
+                bucket_id * (u32.size * 2),
+                command,
+                0
+            );
+
+            shader_gather_bucket.dispatchIndirect({
+                encoder,
+                command,
+                bindings: {
+                    settings: { bucket_id, gathered },
+                    input: buckets,
+                    output,
+                }
+            });
+        }
+    }
+
+    const data = {};
+
+    const pass = graph.add("gather meshes from buckets", data, execute);
+
+    data.buckets = pass.read(buckets);
+    data.commands = bucket_ids.map(() => pass.create("command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR));
+    data.output = pass.create("output", BufferResourceDescriptor.from(
+        limits.compute_buffer_size(RasterizationCollectionType.Meshes),
+        GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+        0, 16 // clear count
+    ));
+
+    return data.output;
+}

package/src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.d.ts

@@ -32,7 +32,8 @@ export function graph_rasterize_scene_fast_raw({ graph, meshes, limits, target_d
  * Flow:
  *  1. Frustum cull the scene meshes
  *  2. Sort culled meshes into rasterization buckets
- *  3. For each active opaque bucket: extract -> expand to meshlets -> rasterize
+ *  3. Gather every active opaque bucket -> expand to meshlets and cut, once -> rasterize a bucket
+ *     at a time
  *  4. If an alpha-tested pass is configured, rasterize it without HZB filtering
  *
  * @param {Object} options

package/src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_scene_fast.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AACH;;;;;;;IAFa;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAC,CAkK3D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAJ+B,KAAK;IACC,GAAG;IACA,MAAM;SA8C7C"}
+{"version":3,"file":"graph_rasterize_scene_fast.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;GAUG;AACH;;;;;;;IAFa;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAC,CAwK3D;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAJ+B,KAAK;IACC,GAAG;IACA,MAAM;SA8C7C"}

package/src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.js

@@ -1,22 +1,19 @@
 import { assert } from "../../../../core/assert.js";
-import { ShadeDrawMode } from "../../material/ShadeDrawMode.js";
 import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
-import { TransparencyMode } from "../../material/TransparencyMode.js";
 import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
 import { graph_import_texture } from "../../shader/graph/graph_import_texture.js";
 import { graph_record_stat } from "../../util/graph_record_stat.js";
 import { rasterization_material_bucket } from "../expand/bucket/chunk_rasterization_material_bucket.js";
 import { graph_meshes_classify_buckets } from "../expand/bucket/mesh/graph_meshes_classify_buckets.js";
-import { graph_meshlets_rasterize } from "../expand/graph_meshlets_rasterize.js";
 import { graph_expand_meshes_to_meshlets } from "../expand/mesh/graph_expand_meshes_to_meshlets.js";
 import { graph_vgeo_expand_if_enabled } from "../../geometry/virtual/runtime/graph_vgeo_expand_if_enabled.js";
 import { RasterizationCollectionType } from "../expand/RasterizationCollectionType.js";
-import { construct_primitive_state } from "../bucket/construct_primitive_state.js";
+import { graph_meshlets_rasterize_by_bucket } from "../bucket/graph_meshlets_rasterize_by_bucket.js";
 import { rasterization_opaque_buckets } from "../bucket/rasterization_opaque_buckets.js";
 import { graph_mesh_frustum_cull } from "../compute/graph_mesh_frustum_cull.js";
 import { graph_clear_raster_targets } from "../graph_clear_raster_targets.js";
 import { graph_rasterize_meshes_alpha_tested } from "../native/graph_rasterize_meshes_alpha_tested.js";
-import { graph_extract_meshes_from_bucket } from "./graph_extract_meshes_from_bucket.js";
+import { graph_gather_meshes_from_buckets } from "./graph_gather_meshes_from_buckets.js";
 
 /**
  *
@@ -74,49 +71,55 @@ export function graph_rasterize_scene_fast_raw({
         active_buckets.add(bucket_id);
     }
 
-    // rasterize each active opaque bucket in a single pass, with no occlusion filtering
+    const opaque = Array.from(rasterization_opaque_buckets(active_buckets));
+
     let is_first_draw = true;
 
-    for (const { draw_mode, side, bucket_id } of rasterization_opaque_buckets(active_buckets)) {
-        const gr_bucket_meshes = graph_extract_meshes_from_bucket({
+    if (opaque.length > 0) {
+        /*
+         Every opaque bucket's meshes in one collection, expanded and cut once, then drawn a bucket at
+         a time with no occlusion filtering. The cut is the one per view (CUT_PLAN_2026_09_14 §7 6b),
+         and the ids are ascending, which is what the gather's count needs.
+        */
+        const gr_opaque_meshes = graph_gather_meshes_from_buckets({
             graph,
             buckets: gr_render_buckets,
-            bucket_id,
+            bucket_ids: opaque.map(bucket => bucket.bucket_id),
             limits,
         });
 
-        let gr_bucket_meshlets = graph_expand_meshes_to_meshlets({
+        let gr_meshlets = graph_expand_meshes_to_meshlets({
             graph,
-            input_meshes: gr_bucket_meshes,
+            input_meshes: gr_opaque_meshes,
             scene: scene_ctx,
             expected_output_size: limits.compute_buffer_size(RasterizationCollectionType.Meshlets),
             limits,
         });
 
-        // the seam: this bucket's virtual-geometry instances select their cut and append it to
-        // the same collection, which is the whole of what the rest of this function is told
-        gr_bucket_meshlets = graph_vgeo_expand_if_enabled({
+        // the seam: the view's virtual-geometry instances select their cut and append it to the
+        // same collection, which is the whole of what the rest of this function is told
+        gr_meshlets = graph_vgeo_expand_if_enabled({
             graph,
-            input_meshes: gr_bucket_meshes,
-            output_meshlets: gr_bucket_meshlets,
+            input_meshes: gr_opaque_meshes,
+            output_meshlets: gr_meshlets,
             view: view_ctx,
             limits,
         });
 
-        graph_record_stat(graph, limits.stats, RasterizationCollectionType.Meshlets, gr_bucket_meshlets);
+        graph_record_stat(graph, limits.stats, RasterizationCollectionType.Meshlets, gr_meshlets);
 
-        const primitive_state = construct_primitive_state(draw_mode, side, job.cull_policy);
-
-        [target_depth, targets_color] = graph_meshlets_rasterize({
+        [target_depth, targets_color] = graph_meshlets_rasterize_by_bucket({
             graph,
             view: view_ctx,
-            input_meshlets: gr_bucket_meshlets,
+            input_meshlets: gr_meshlets,
+            buckets: opaque,
             depth: target_depth,
             color_targets: targets_color,
             pass_descriptor: job.opaque_pass,
-            clear_targets: is_first_draw,
-            primitive_state,
+            clear_targets: true,
+            cull_policy: job.cull_policy,
             viewport,
+            limits,
         });
 
         is_first_draw = false;
@@ -203,7 +206,8 @@ export function graph_rasterize_scene_fast_raw({
  * Flow:
  *  1. Frustum cull the scene meshes
  *  2. Sort culled meshes into rasterization buckets
- *  3. For each active opaque bucket: extract -> expand to meshlets -> rasterize
+ *  3. Gather every active opaque bucket -> expand to meshlets and cut, once -> rasterize a bucket
+ *     at a time
  *  4. If an alpha-tested pass is configured, rasterize it without HZB filtering
  *
  * @param {Object} options

package/src/shade/renderer/rasterize/native/avboit/AVBOIT_LEDGER.md

@@ -887,3 +887,23 @@ reach — the dynamic-mesh directory, the orchestrator run with a real channel,
 93 tests — passes, and the type check is at budget. On the Metal adapter, `@builtin(sample_mask)` and
 `@interpolate(perspective, centroid)` compile and the multisampled pipeline builds; no uncaptured device
 errors, including 240 frames of a live trail on a moving path, fading in and out.
+
+## 25. A trail's draw constants go up once a frame — 2026-09-27
+
+Entry 23 left each live mesh's constants built twice — a transient uniform and a bind group of its own
+for the splat, and again for the draw — noted, not shaved. They are shaved here, as part of moving
+every dynamic mesh's per-draw constants into a table (CHANGELOG, Unreleased, Rendering): the
+occupancy, after its upload, writes the frame's `GPUDynamicMeshDrawList` — one transient storage
+buffer and one write per 1,024 draws — and the splat and the draw both bind it and name their rows by
+`first_instance`. The splat's layout is four groups now (constants, geometry, warp, volume), which is
+WebGPU's default `maxBindGroups`.
+
+**Measured** with 1,500 live meshes through the channel at 1280×720 on the RTX 4090, asserts
+stripped, paired: 9.8–11.4 ms of CPU a frame to 2.0–2.5; 3,032 copies a frame to 34 and 7,624
+`setBindGroup` to 3,131. The pictures after equal frame counts are bit-identical to before.
+
+**Verified.** `DynamicMeshAVBOITChannel.draws.spec.js` checks the splat and the draw read each mesh's own
+constants from one table, and fails with a draw pass that uploads its own copy (two tables).
+`chunk_dynamic_mesh_vertex.spec.js` runs the shared AVBOIT vertex stage on the emulator and checks a
+vertex is carried by the row its draw names. The other half of the item — the emptiness query and the
+gather both walking the first live mesh's triangles — is left as it was.

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":"AAyBA;;;;;;;;;;;;;;;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,CAmNjG"}
+{"version":3,"file":"graph_rasterize_partial_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;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"}

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

@@ -3,9 +3,6 @@ import { noop } from "../../../../core/function/noop.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { shader_hzb_mesh_filter_2way } from "../cull/hzb/shader_hzb_mesh_filter_2way.js";
-import { ShadeDrawMode } from "../../material/ShadeDrawMode.js";
-import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
-import { TransparencyMode } from "../../material/TransparencyMode.js";
 import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
 import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
 import { graph_record_stat } from "../../util/graph_record_stat.js";
@@ -14,12 +11,12 @@ import {
     graph_build_indirect_dispatch_command,
     INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
 } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
-import { graph_meshlets_rasterize } from "../expand/graph_meshlets_rasterize.js";
 import { graph_expand_meshes_to_meshlets } from "../expand/mesh/graph_expand_meshes_to_meshlets.js";
 import { graph_vgeo_expand_if_enabled } from "../../geometry/virtual/runtime/graph_vgeo_expand_if_enabled.js";
 import { MeshletFilter2WayPassData, pass_filter_meshlets_2way } from "../expand/pass1/pass_filter_meshlets_2way.js";
 import { RasterizationCollectionType } from "../expand/RasterizationCollectionType.js";
-import { construct_primitive_state, CullPolicy } from "../bucket/construct_primitive_state.js";
+import { CullPolicy } from "../bucket/construct_primitive_state.js";
+import { graph_meshlets_rasterize_by_bucket } from "../bucket/graph_meshlets_rasterize_by_bucket.js";
 import { rasterization_opaque_buckets } from "../bucket/rasterization_opaque_buckets.js";
 import { graph_clear_raster_targets } from "../graph_clear_raster_targets.js";
 
@@ -110,9 +107,6 @@ export function graph_rasterize_partial_opaque({
             },
             command
         });
-
-        limits.stats.record(encoder, RasterizationCollectionType.Meshes, instances_positive);
-
     }
 
 
@@ -122,6 +116,17 @@ export function graph_rasterize_partial_opaque({
     // create a dummy pass to spawn persistent resources
     const dummy_pass = graph.add('dummy/spawn', {}, noop);
 
+    /*
+     One positive set for every bucket, as the maybe set always was. The filter appends, so each
+     bucket's pass adds its instances to what the buckets before it left, and what comes out of the
+     loop is every instance the view draws in this phase — which is what gets expanded and cut, once
+     (CUT_PLAN_2026_09_14 §7 6b).
+    */
+    let gr_instances_positive = dummy_pass.create("positive meshes", BufferResourceDescriptor.from(
+        collection_size_meshes,
+        GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+        0, 16
+    ));
     let gr_instances_maybe = dummy_pass.create("maybe meshes", BufferResourceDescriptor.from(
         collection_size_meshes,
         GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
@@ -136,10 +141,9 @@ export function graph_rasterize_partial_opaque({
 
     let viz_depth = depth;
 
+    const opaque = Array.from(rasterization_opaque_buckets(active_buckets));
 
-    let is_first_draw = true;
-
-    for (const { draw_mode, side, bucket_id } of rasterization_opaque_buckets(active_buckets)) {
+    for (const { bucket_id } of opaque) {
         const pass_data_instances_0 = {};
 
         const pass_instances_0 = graph.add("HZB mesh filter", pass_data_instances_0, execute);
@@ -151,33 +155,34 @@ export function graph_rasterize_partial_opaque({
         pass_data_instances_0.camera_previous = pass_instances_0.read(camera_previous);
         pass_data_instances_0.hzb = pass_instances_0.read(hzb);
 
-        pass_data_instances_0.instances_positive = pass_instances_0.create("positive meshes", BufferResourceDescriptor.from(
-            collection_size_meshes,
-            GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
-            0, 16
-        ));
-
+        gr_instances_positive = pass_data_instances_0.instances_positive = pass_instances_0.write(gr_instances_positive);
         gr_instances_maybe = pass_data_instances_0.instances_maybe = pass_instances_0.write(gr_instances_maybe);
+    }
+
+    let is_first_draw = true;
+
+    if (opaque.length > 0) {
+        graph_record_stat(graph, limits.stats, RasterizationCollectionType.Meshes, gr_instances_positive);
 
         let meshlet_expansion_0 = graph_expand_meshes_to_meshlets({
             graph,
-            input_meshes: pass_data_instances_0.instances_positive,
+            input_meshes: gr_instances_positive,
             scene: scene_ctx,
             expected_output_size: collection_size_meshlets,
             limits,
         });
 
-        // the seam. The instance sets of the two HZB passes are disjoint, so cutting each of
-        // them costs one cut per view in total and no instance is ever cut twice
+        // the seam, over every opaque bucket at once. The instance sets of the two HZB passes are
+        // disjoint, so this and the second phase's are one cut per view in total, and no instance
+        // is ever cut twice
         meshlet_expansion_0 = graph_vgeo_expand_if_enabled({
             graph,
-            input_meshes: pass_data_instances_0.instances_positive,
+            input_meshes: gr_instances_positive,
             output_meshlets: meshlet_expansion_0,
             view,
             limits,
         });
 
-
         graph_record_stat(graph, limits.stats, RasterizationCollectionType.Meshlets, meshlet_expansion_0);
 
         // ----------
@@ -201,22 +206,21 @@ export function graph_rasterize_partial_opaque({
         ));
         gr_meshlets_maybe = pass_data_meshlets_1.out_meshlets_maybe = pass_meshlets_1.write(gr_meshlets_maybe);
 
-        const primitive_state = construct_primitive_state(draw_mode, side, cull_policy);
-
         // ----------
-        [viz_depth, raster_color_targets] = graph_meshlets_rasterize({
+        [viz_depth, raster_color_targets] = graph_meshlets_rasterize_by_bucket({
             graph,
             view,
             input_meshlets: pass_data_meshlets_1.out_meshlets_positive,
+            buckets: opaque,
             depth: viz_depth,
             color_targets: raster_color_targets,
             pass_descriptor: render_pass_descriptor,
-            clear_targets: is_first_draw,
-            primitive_state,
+            clear_targets: true,
+            cull_policy,
             viewport,
+            limits,
         });
 
-        //
         is_first_draw = false;
     }
 

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":"AA6FA;;;;;;;;;;;;;;;;;GAiBG;AACH,kOAFa;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAkGlD"}
+{"version":3,"file":"graph_rasterize_remaining_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;GAiBG;AACH,kOAFa;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAqFlD"}

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

@@ -1,96 +1,13 @@
-import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { STRUCT_DISPATCH_COMPUTE_COMMAND } from "../../gpu_primitive/indirect/STRUCT_DISPATCH_COMPUTE_COMMAND.js";
-import { ShadeDrawMode } from "../../material/ShadeDrawMode.js";
-import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
-import { TransparencyMode } from "../../material/TransparencyMode.js";
-import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
 import { graph_record_stat } from "../../util/graph_record_stat.js";
-import { build_indirect_compute_dispatch_command } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
-import { graph_sort_meshlets_by_bucket_id } from "../expand/bucket/meshlet/graph_sort_meshlets_by_bucket_id.js";
-import { shader_meshlets_extract_bucket } from "../expand/bucket/meshlet/shader_meshlets_extract_bucket.js";
 import { graph_mesh_filter_one_way } from "../expand/graph_mesh_filter_one_way.js";
 import { graph_meshlets_filter_one_way } from "../expand/graph_meshlets_filter_one_way.js";
-import { graph_meshlets_rasterize } from "../expand/graph_meshlets_rasterize.js";
 import { graph_expand_meshes_to_meshlets } from "../expand/mesh/graph_expand_meshes_to_meshlets.js";
 import { graph_vgeo_expand_if_enabled } from "../../geometry/virtual/runtime/graph_vgeo_expand_if_enabled.js";
 import { RasterizationCollectionType } from "../expand/RasterizationCollectionType.js";
-import { construct_primitive_state, CullPolicy } from "../bucket/construct_primitive_state.js";
+import { CullPolicy } from "../bucket/construct_primitive_state.js";
+import { graph_meshlets_rasterize_by_bucket } from "../bucket/graph_meshlets_rasterize_by_bucket.js";
 import { rasterization_opaque_buckets } from "../bucket/rasterization_opaque_buckets.js";
 
-/**
- *
- * @param {Object} options
- * @param {FrameGraph} options.graph
- * @param {number} options.buckets
- * @param {number} options.bucket_id
- * @param {GPUCollectionLimits} options.limits
- */
-function graph_extract_meshlets_from_bucket({
-                                                graph,
-                                                buckets,
-                                                bucket_id,
-                                                limits,
-                                            }) {
-
-    /**
-     *
-     * @param data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute(data, resources, context) {
-        const encoder = context.encoder;
-
-        const buckets = resources.get(data.buckets);
-        const output = resources.get(data.output);
-        const command = resources.get(data.command);
-
-        const bucket_id = data.bucket_id;
-
-        // folded: a meshlet collection is past what one dispatch dimension reaches — see
-        // IndirectComputeCommandBuildPass
-        build_indirect_compute_dispatch_command(
-            COMPUTE_SHADER_DEFAULT_GROUP_SIZE,
-            encoder,
-            buckets,
-            // the bucketed buffer header consists of pairs of u32 values (count,offset)
-            bucket_id * (u32.size * 2),
-            command,
-            0,
-            true,
-        );
-
-        shader_meshlets_extract_bucket.dispatchIndirect({
-            encoder,
-            command,
-            bindings: {
-                bucket_index: { value: bucket_id },
-                bucket_data: buckets,
-                output: output,
-            }
-        });
-    }
-
-    const data = {};
-
-    const pass = graph.add("extract meshlets from bucket", data, execute);
-
-    data.buckets = pass.read(buckets);
-    data.bucket_id = bucket_id;
-    data.command = pass.create("command", BufferResourceDescriptor.from(
-        STRUCT_DISPATCH_COMPUTE_COMMAND.aligned_size,
-        GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT,
-    ));
-    data.output = pass.create("output", BufferResourceDescriptor.from(
-        limits.compute_buffer_size(RasterizationCollectionType.Meshlets),
-        GPUBufferUsage.STORAGE,
-        0, 16 // clear count
-    ));
-
-    return data.output;
-}
-
 /**
  *
  * @param {FrameGraph} graph
@@ -170,34 +87,21 @@ export function graph_rasterize_remaining_opaque({
     });
 
 
-    const meshlet_buckets = graph_sort_meshlets_by_bucket_id({
-        graph,
-        input_meshlets: gr_live_meshlets,
-        scene_ctx: view.scene,
-        limits,
-    });
-
-    for (const { draw_mode, side, bucket_id } of rasterization_opaque_buckets(active_buckets)) {
-        const primitive_state = construct_primitive_state(draw_mode, side, cull_policy);
-
-        // copy out a meshlet set
-        const meshlets = graph_extract_meshlets_from_bucket({
-            graph,
-            buckets: meshlet_buckets,
-            bucket_id,
-            limits,
-        });
+    const opaque = Array.from(rasterization_opaque_buckets(active_buckets));
 
-        [gr_depth_texture, raster_color_targets] = graph_meshlets_rasterize({
+    if (opaque.length > 0) {
+        [gr_depth_texture, raster_color_targets] = graph_meshlets_rasterize_by_bucket({
             graph,
             view,
-            input_meshlets: meshlets,
+            input_meshlets: gr_live_meshlets,
+            buckets: opaque,
             depth: gr_depth_texture,
             color_targets: raster_color_targets,
             pass_descriptor: render_pass_descriptor,
             clear_targets: false,
-            primitive_state,
+            cull_policy,
             viewport,
+            limits,
         });
     }
 

package/src/shade/renderer/scene/GPUInstancesAccelerationStructure.d.ts

@@ -69,6 +69,11 @@ export class GPUInstancesAccelerationStructure {
      * on its own — what a frame does, so the build follows the bounds pass it reads
      */
     update(scene_database_buffer: GPUBuffer, cmd_ctx?: ShadeGPUCommandContext): void;
+    /**
+     * Release the tree and the list of rows it was built over. For the scene context's own
+     * teardown: nothing builds or reads the tree afterwards. Safe to call twice.
+     */
+    destroy(): void;
     #private;
 }
 export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;

package/src/shade/renderer/scene/GPUInstancesAccelerationStructure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUInstancesAccelerationStructure.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUInstancesAccelerationStructure.js"],"names":[],"mappings":"AAmCA;;GAEG;AACH;IA8DI;;;OAGG;IACH,sBAFW,eAAe,EAqBzB;IAzED,cAIC;IAOD;;;OAGG;IACH,wBAEC;IAmED;;;;OAIG;IACH,oBAFW,MAAM,QAUhB;IAED;;;;;OAKG;IACH,uBAFW,MAAM,QAUhB;IAED;;;;OAIG;IACH,uBAFW,MAAM,QAOhB;IA8CD;;;;OAIG;IACH;;;OAGG;IACH,mBAEC;IAiGD;;;;;;;;;;;;OAYG;IACH,0BAHW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,GAChC,QAAQ,OAAO,CAAC,CA0C5B;IAED;;;OAGG;IACH,wDAFW,sBAAsB,QAMhC;IAED;;;;;;OAMG;IACH,mDAHW,sBAAsB,QAShC;;CACJ;8BA7YY,OAAO,uBAAuB,EAAE,eAAe;uCARrB,wCAAwC"}
+{"version":3,"file":"GPUInstancesAccelerationStructure.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUInstancesAccelerationStructure.js"],"names":[],"mappings":"AAmCA;;GAEG;AACH;IA8DI;;;OAGG;IACH,sBAFW,eAAe,EAqBzB;IAzED,cAIC;IAOD;;;OAGG;IACH,wBAEC;IAmED;;;;OAIG;IACH,oBAFW,MAAM,QAUhB;IAED;;;;;OAKG;IACH,uBAFW,MAAM,QAUhB;IAED;;;;OAIG;IACH,uBAFW,MAAM,QAOhB;IA8CD;;;;OAIG;IACH;;;OAGG;IACH,mBAEC;IAiGD;;;;;;;;;;;;OAYG;IACH,0BAHW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,GAChC,QAAQ,OAAO,CAAC,CA0C5B;IAED;;;OAGG;IACH,wDAFW,sBAAsB,QAMhC;IAED;;;;;;OAMG;IACH,mDAHW,sBAAsB,QAShC;IAED;;;OAGG;IACH,gBAKC;;CACJ;8BAxZY,OAAO,uBAAuB,EAAE,eAAe;uCARrB,wCAAwC"}

package/src/shade/renderer/scene/GPUInstancesAccelerationStructure.js

@@ -406,6 +406,17 @@ export class GPUInstancesAccelerationStructure {
 
         this.push_to_gpu(scene_database_buffer, cmd_ctx);
     }
+
+    /**
+     * Release the tree and the list of rows it was built over. For the scene context's own
+     * teardown: nothing builds or reads the tree afterwards. Safe to call twice.
+     */
+    destroy() {
+        this.#buffer.destroy();
+        this.#rows_buffer?.destroy();
+
+        this.#live.clear();
+    }
 }
 
 /**

package/src/shade/renderer/scene/GPUSceneContext.d.ts

@@ -75,9 +75,10 @@ export class GPUSceneContext {
      *
      * And the residency and the feedback loop with it, so that an engine host gets the whole
      * streaming loop by enabling virtual geometry rather than by wiring four objects itself
-     * (REVIEW_LEDGER U1): `register` a container with {@link virtual_geometry_residency}, call
-     * {@link virtual_geometry_feedback}'s `read` once a frame after the last rasterization path,
-     * and every page after the root arrives because the cut asked for it.
+     * (REVIEW_LEDGER U1): `register` a container with {@link virtual_geometry_residency}, and every
+     * page after the root arrives because a cut asked for it. The renderer opens and closes each
+     * frame and schedules each reading, and {@link destroy} releases all of it; a host touches none
+     * of it.
      *
      * @param {Object} [options] passed to {@link GPUVirtualGeometryPool} and
      *     {@link GPUVirtualGeometryRuntime}, except for `residency`
@@ -181,6 +182,13 @@ export class GPUSceneContext {
      * @param {number} dt_seconds wall-clock seconds since last call
      */
     tick(cmd_ctx: ShadeGPUCommandContext, dt_seconds: number): void;
+    /**
+     * Release this context's virtual geometry — everything {@link enable_virtual_geometry} built,
+     * so that a host tears a scene down by destroying the renderer and nothing of the streaming loop
+     * is left for it to find — then its rows, its database, its TLAS, its lights, its probe volume,
+     * its volumetrics, its volumetric light map, its animation and its skinning: every buffer the
+     * context made. Safe to call twice, and on a context that never enabled virtual geometry.
+     */
     destroy(): void;
     /**
      * @readonly

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAiCf;IA5KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAoHD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAmCrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD,gBAYC;IAIL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA9pBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAiCf;IA5KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2HD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAiBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAtuBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}