@woosh/meep-engine 3.33.0 → 3.35.0

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

@@ -708,6 +708,9 @@ export function avboit_create_accumulators(pass, resolution) {
  * @param {number} options.shadowmap_atlas
  * @param {number} options.volumetrics_lut
  * @param {number} options.volumetrics_metadata
+ * @param {{Y: number, CoCg: number}} options.volumetrics_irradiance the froxel irradiance volume
+ *   (`chunk_volumetrics_irradiance_sh`), for side channels that light their own fragments; the
+ *   MBOIT orchestrator ignores it
  * @param {ShadeIndirectLightingMode} options.indirect_lighting_mode
  * @param {AVBOITSettings} [options.avboit] `Renderer.avboit`; the MBOIT orchestrator ignores it
  * @param {import("./AVBOITSideChannel.js").AVBOITSideChannel[]} [options.side_channels] non-meshlet
@@ -730,6 +733,7 @@ export function graph_rasterize_meshes_transparent_avboit({
 
                                                               volumetrics_lut,
                                                               volumetrics_metadata,
+                                                              volumetrics_irradiance,
 
                                                               indirect_lighting_mode = ShadeIndirectLightingMode.IBL,
                                                               avboit = DEFAULT_SETTINGS,
@@ -747,6 +751,10 @@ export function graph_rasterize_meshes_transparent_avboit({
 
     assert.isNonNegativeInteger(shadowmap_atlas, 'shadowmap_atlas');
 
+    assert.defined(volumetrics_irradiance, 'volumetrics_irradiance');
+    assert.isNonNegativeInteger(volumetrics_irradiance.Y, 'volumetrics_irradiance.Y');
+    assert.isNonNegativeInteger(volumetrics_irradiance.CoCg, 'volumetrics_irradiance.CoCg');
+
     assert.equal(view_ctx.isGPUViewContext, true, 'view_ctx.isGPUViewContext !== true');
 
     const scene_ctx = view_ctx.scene;
@@ -971,6 +979,7 @@ export function graph_rasterize_meshes_transparent_avboit({
             integral,
             volumetrics_lut,
             volumetrics_metadata,
+            volumetrics_irradiance,
             accumulators,
         });
     }

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

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

@@ -273,12 +273,19 @@ export class GPUSceneContext {
 
     /**
      * The feedback loop that carries the cut's readings into the residency, once
-     * {@link enable_virtual_geometry} has run. A host calls its `read` once a frame after every
-     * rasterization path has cut.
+     * {@link enable_virtual_geometry} has run. The renderer reads it once a frame after every
+     * rasterization path has cut; a host does not.
      * @type {VGeoFeedbackLoop|undefined}
      */
     #virtual_geometry_feedback;
 
+    /**
+     * Where the residency's pages are fetched, and the workers that fetch them. This context made
+     * it and handed it in, so the residency does not release it and {@link destroy} does.
+     * @type {VGeoPageFetcher|undefined}
+     */
+    #virtual_geometry_fetcher;
+
     /**
      * @returns {GPUVirtualGeometryRuntime|undefined}
      */
@@ -310,9 +317,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`
@@ -332,26 +340,46 @@ export class GPUSceneContext {
             ...rest,
         });
 
-        this.#virtual_geometry = new GPUVirtualGeometryRuntime({
-            pool,
-            ...rest,
-        });
+        /*
+         All four or none. Installed one at a time, a throw partway — options a residency refuses —
+         left a runtime on offer with no loop behind it, and destroy() then threw on the missing loop
+         before it reached the rest of the scene.
+        */
+        let runtime;
+        let fetcher;
+        let tiers;
+        let feedback;
+
+        try {
+            runtime = new GPUVirtualGeometryRuntime({
+                pool,
+                ...rest,
+            });
 
-        // pages are fetched, verified and decoded on workers, spawned on first use; a host with no
-        // Worker gets the same fetch in-process
-        const fetcher = new VGeoPageFetcher({
-            worker_count: residency.worker_count,
-            make_worker: typeof Worker === 'undefined' ? undefined : make_vgeo_page_worker,
-        });
+            // pages are fetched, verified and decoded on workers, spawned on first use; a host with
+            // no Worker gets the same fetch in-process
+            fetcher = new VGeoPageFetcher({
+                worker_count: residency.worker_count,
+                make_worker: typeof Worker === 'undefined' ? undefined : make_vgeo_page_worker,
+            });
 
-        this.#virtual_geometry_residency = new VGeoResidency({ pool, options: residency, fetcher });
+            tiers = new VGeoResidency({ pool, options: residency, fetcher });
 
-        this.#virtual_geometry_feedback = new VGeoFeedbackLoop({
-            runtime: this.#virtual_geometry,
-            residency: this.#virtual_geometry_residency,
-        });
+            feedback = new VGeoFeedbackLoop({ runtime, residency: tiers });
+        } catch (error) {
+            // the pool is the only one holding anything yet: the fetcher spawns its workers on its
+            // first fetch, and the runtime makes its buffer on its first frame
+            pool.destroy();
 
-        return this.#virtual_geometry;
+            throw error;
+        }
+
+        this.#virtual_geometry = runtime;
+        this.#virtual_geometry_fetcher = fetcher;
+        this.#virtual_geometry_residency = tiers;
+        this.#virtual_geometry_feedback = feedback;
+
+        return runtime;
     }
 
     /**
@@ -683,20 +711,64 @@ export class GPUSceneContext {
         });
     }
 
+    /**
+     * 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() {
+        this.#destroy_virtual_geometry();
+
         if (this.#rows !== null) {
             this.#rows.destroy();
         }
 
         this.#scene_database.destroy();
+        this.#tlas.destroy();
         this.#lights.destroy();
         this.#light_probe_volume.destroy();
+        this.#volumetrics.destroy();
+        this.volumetric_light_map.destroy();
         this.#animation_manager.destroy();
         if (this.#skinning !== null) {
             this.#skinning.destroy();
         }
     }
 
+    /**
+     * Everything {@link enable_virtual_geometry} built, in the order it depends on itself: the work
+     * still outstanding first — the loop's and the residency's fetches, and the workers they run on
+     * — because each of those lands on the pool's rows when it finishes, and then the device memory,
+     * the runtime's feedback buffer before the pool's tables that its frames write into.
+     *
+     * Afterwards the scene has no virtual geometry, which is what every rasterization path already
+     * takes to mean "skip the cut".
+     */
+    #destroy_virtual_geometry() {
+        const runtime = this.#virtual_geometry;
+
+        if (runtime === undefined) {
+            return;
+        }
+
+        this.#virtual_geometry_feedback.destroy();
+
+        // gives back every container's rows and slots, and cancels what they had on the wire
+        this.#virtual_geometry_residency.destroy();
+
+        this.#virtual_geometry_fetcher.destroy();
+
+        runtime.destroy();
+        runtime.pool.destroy();
+
+        this.#virtual_geometry = undefined;
+        this.#virtual_geometry_residency = undefined;
+        this.#virtual_geometry_feedback = undefined;
+        this.#virtual_geometry_fetcher = undefined;
+    }
+
 }
 
 /**

package/src/shade/renderer/scene/rows/GPUSceneRows.d.ts

@@ -220,7 +220,10 @@ export class GPUSceneRows {
      */
     for_each_descendant(entity: number, visitor: (arg0: number) => void): void;
     /**
-     * Forget everything, freeing every row. For the context's own teardown.
+     * Forget everything. For the context's own teardown, which destroys the tables and the tree
+     * next — so no row is given back to them one at a time, which cost about 2 µs a row and took a
+     * scene of millions seconds to leave. What outlives the context is not the rows' to give back:
+     * the skinned clones go back to the shared geometry manager with the skinning context.
      */
     destroy(): void;
     #private;

package/src/shade/renderer/scene/rows/GPUSceneRows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneRows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUSceneRows.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAoID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IA2II;;;;;;;;;OASG;IACH;QAR2C,OAAO,EAAvC,sBAAsB;QACC,UAAU;QACV,MAAM;QACD,UAAU,EAAtC,kBAAkB;QACU,SAAS,EAArC,kBAAkB;QACyB,IAAI,EAA/C,iCAAiC;QACW,QAAQ,QAAxC,sBAAsB;OAmB5C;IAED;;OAEG;IACH,iGAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,oBAA8B;IAE9B;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,KAAG,IAAI,QASzE;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAuChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,QAgDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAwCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IAyMD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;OAEG;IACH,gBA+BC;;CACJ;qCA5oCY,OAAO,kDAAkD,EAAE,sBAAsB;;iCAEjF,OAAO,sCAAsC,EAAE,kBAAkB;iCACjE,OAAO,sCAAsC,EAAE,kBAAkB;gDACjE,OAAO,yCAAyC,EAAE,iCAAiC;qCACnF,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;oBACvD,OAAO,wCAAwC,EAAE,KAAK"}
+{"version":3,"file":"GPUSceneRows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUSceneRows.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAoID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IA2II;;;;;;;;;OASG;IACH;QAR2C,OAAO,EAAvC,sBAAsB;QACC,UAAU;QACV,MAAM;QACD,UAAU,EAAtC,kBAAkB;QACU,SAAS,EAArC,kBAAkB;QACyB,IAAI,EAA/C,iCAAiC;QACW,QAAQ,QAAxC,sBAAsB;OAmB5C;IAED;;OAEG;IACH,iGAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,oBAA8B;IAE9B;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,KAAG,IAAI,QASzE;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAuChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,QAgDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAwCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IAyMD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;;;;OAKG;IACH,gBAUC;;CACJ;qCA1nCY,OAAO,kDAAkD,EAAE,sBAAsB;;iCAEjF,OAAO,sCAAsC,EAAE,kBAAkB;iCACjE,OAAO,sCAAsC,EAAE,kBAAkB;gDACjE,OAAO,yCAAyC,EAAE,iCAAiC;qCACnF,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;oBACvD,OAAO,wCAAwC,EAAE,KAAK"}

package/src/shade/renderer/scene/rows/GPUSceneRows.js

@@ -1143,33 +1143,15 @@ export class GPUSceneRows {
     }
 
     /**
-     * Forget everything, freeing every row. For the context's own teardown.
+     * Forget everything. For the context's own teardown, which destroys the tables and the tree
+     * next — so no row is given back to them one at a time, which cost about 2 µs a row and took a
+     * scene of millions seconds to leave. What outlives the context is not the rows' to give back:
+     * the skinned clones go back to the shared geometry manager with the skinning context.
      */
     destroy() {
-        for (const [entity, entry] of this.#mesh_entries) {
-            if (entry.written) {
-                const row = row_of_entity(entity);
-
-                this.#meshes.remove(row);
-                this.#tlas.instance_remove(row);
-
-                if (entry.skinned) {
-                    this.#skinning().release_clone(entity);
-                }
-            }
-        }
-
         this.#mesh_entries.clear();
 
-        const acquired = this.#acquired;
-
-        for (let entity = acquired.nextSetBit(0); entity !== -1; entity = acquired.nextSetBit(entity + 1)) {
-            if (this.#written.get(entity)) {
-                this.#transforms.remove(row_of_entity(entity));
-            }
-        }
-
-        acquired.reset();
+        this.#acquired.reset();
         this.#written.reset();
         this.#reason.fill(0);
         this.#holds.fill(0);

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAuFA;;GAEG;AACH;IAgPI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EA+D5B;IApTD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IA2BtC;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IA8ED;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAkGD;;;;;OAKG;IACH,iCAMC;IAgHD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QAgE3B;IAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QAsFhC;IAsbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAwOnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAiBC;;CACJ;qCAn9CY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;oCA9DX,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}
+{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AA0FA;;GAEG;AACH;IAgPI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EAiE5B;IAtTD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IA2BtC;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IA8ED;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAoGD;;;;;OAKG;IACH,iCAMC;IAoKD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QAoE3B;IAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QAwFhC;IAsbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAwOnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAiBC;;CACJ;qCA/gDY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;oCAhEX,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}