@woosh/meep-engine 3.59.0 → 3.60.1

package/src/shade/renderer/path_tracer/shader/chunk_indirect_texture_load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_indirect_texture_load.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_indirect_texture_load.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH,0CAFU,SAAS,CAgCjB;0BAzCwB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_indirect_texture_load.js

@@ -0,0 +1,49 @@
+import {
+    RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
+    RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION,
+    RESIDENT_MATERIAL_TEXTURE_SLOTS_PER_LAYER
+} from "../../material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.js";
+import { chunk_coordinate_wrap } from "../../shader/chunk/texture/chunk_coordinate_wrap.js";
+import { SAMPLER_DESCRIPTOR_STRUCT } from "../../shader/chunk/texture/SAMPLER_DESCRIPTOR_STRUCT.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * One texel of a resident material texture: `indirect_texture_load(id, sampler, texel, level)`, the texel
+ * at the integer-valued coordinate `texel` of texture `id`'s slot at mip `level`, the coordinate wrapped
+ * within the slot at that level by the sampler's address modes (RESIDENT_MATERIAL_TEXTURE_LAYOUT).
+ *
+ * Reads the `textures` atlas binding, which the shader that includes it declares.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_indirect_texture_load = CodeChunk.from(
+//language=WGSL
+    `
+fn indirect_texture_load(id: u32, sampler: ${SAMPLER_DESCRIPTOR_STRUCT.wgsl_ref}, texel: vec2<f32>, level: u32) -> vec4<f32> {
+
+    // figure out slot
+    let slot_z = id / ${RESIDENT_MATERIAL_TEXTURE_SLOTS_PER_LAYER};
+
+    let in_slice_id = id - slot_z * ${RESIDENT_MATERIAL_TEXTURE_SLOTS_PER_LAYER};
+
+    let slot_y = in_slice_id / ${RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION};
+    let slot_x = in_slice_id % ${RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION};
+
+    let size = ${RESIDENT_MATERIAL_TEXTURE_RESOLUTION}u >> level;
+
+    // Texture Wrapping (per-axis, S->U / T->V)
+    let wrapped_coord = vec2(
+        coordinate_wrap(texel.x, f32(size), sampler.address_mode_u),
+        coordinate_wrap(texel.y, f32(size), sampler.address_mode_v),
+    );
+
+    // Convert to atlas space
+    let pixel_coord = vec2<u32>(slot_x, slot_y) * size + vec2<u32>(wrapped_coord);
+
+    return textureLoad(textures, pixel_coord, slot_z, level);
+}
+    `, [
+        SAMPLER_DESCRIPTOR_STRUCT.declaration_chunk,
+        chunk_coordinate_wrap,
+    ]
+);

package/src/shade/renderer/path_tracer/shader/chunk_ray_hit_to_opacity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ray_hit_to_opacity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_ray_hit_to_opacity.js"],"names":[],"mappings":"AASA,iDAmCC;0BAvCyB,oCAAoC"}
+{"version":3,"file":"chunk_ray_hit_to_opacity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_ray_hit_to_opacity.js"],"names":[],"mappings":"AASA,iDAoCC;0BAxCyB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_ray_hit_to_opacity.js

@@ -33,6 +33,7 @@ fn ray_hit_to_opacity(
         triangle_lambda,
         node.global,
         ray_direction,
+        0.0,
     );
 }
     `, [

package/src/shade/renderer/path_tracer/shader/chunk_render_trace_path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_render_trace_path.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_render_trace_path.js"],"names":[],"mappings":"AA2CA,oDAIG;AAEH;;;;;;GAMG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;;;;GAOG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,gCAFU,MAAM,CAEsB;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,gDAwhBE;6BA5pB2B,mCAAmC;0BA2BtC,oCAAoC"}
+{"version":3,"file":"chunk_render_trace_path.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_render_trace_path.js"],"names":[],"mappings":"AA2CA,oDAIG;AAEH;;;;;;GAMG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;;;;GAOG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,gCAFU,MAAM,CAEsB;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,gDAyhBE;6BA7pB2B,mCAAmC;0BA2BtC,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_render_trace_path.js

@@ -272,6 +272,7 @@ fn render_trace_path(
             triangle_info,
             triangle_lambda,
             node.global,
+            0.0,
         );
 
         shading_closure_from_material_data(

package/src/shade/renderer/path_tracer/shader/chunk_sample_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material.js"],"names":[],"mappings":"AASA,8CAmCO;0BAxCmB,oCAAoC"}
+{"version":3,"file":"chunk_sample_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material.js"],"names":[],"mappings":"AASA,8CAoCO;0BAzCmB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_sample_material.js

@@ -25,7 +25,8 @@ fn sample_material(
         material,
         triangle,
         lambda,
-        instance_transform
+        instance_transform,
+        0.0
     );
     
     shading_closure_from_material_data(

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.d.ts

@@ -3,6 +3,13 @@
  * @type {CodeChunk}
  */
 export const chunk_sample_material_alpha: CodeChunk;
+/**
+ * The resident material at a hit: `sample_material_data(incoming_ray, material, triangle, lambda,
+ * instance_transform, texture_level)`, its textures read at `texture_level` — see
+ * {@link chunk_indirect_sample_texture}. Every texture's slot is the same size, so one level serves all
+ * four.
+ * @type {CodeChunk}
+ */
 export const chunk_sample_material_data: CodeChunk;
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_sample_material_data.d.ts.map

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH,0CAFU,SAAS,CA+FlB;AAED,mDAwIC;0BAnPyB,oCAAoC"}
+{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH,0CAFU,SAAS,CAgGlB;AAED;;;;;;GAMG;AACH,yCAFU,SAAS,CA2IlB;0BA5PyB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js

@@ -45,6 +45,7 @@ fn sample_material_alpha(
     lambda: vec3<f32>,
     instance_transform: mat4x4<f32>,
     ray_direction: vec3<f32>,
+    texture_level: f32,
 ) -> ${RAY_HIT_TRANSPARENT_SURFACE_DESCRIPTION_STRUCT.wgsl_ref}{
 
     let vertex_0 = triangle.a;
@@ -63,7 +64,7 @@ fn sample_material_alpha(
         lambda
     );
 
-    var texture_sample_diffuse = indirect_sample_texture(material.texture_albedo, material.sampler_albedo, uv).rgba;
+    var texture_sample_diffuse = indirect_sample_texture(material.texture_albedo, material.sampler_albedo, uv, texture_level).rgba;
 
     var normal_model_matrix = compute_normal_matrix_from_m4(instance_transform);
 
@@ -131,6 +132,13 @@ fn sample_material_alpha(
     ]
 )
 
+/**
+ * The resident material at a hit: `sample_material_data(incoming_ray, material, triangle, lambda,
+ * instance_transform, texture_level)`, its textures read at `texture_level` — see
+ * {@link chunk_indirect_sample_texture}. Every texture's slot is the same size, so one level serves all
+ * four.
+ * @type {CodeChunk}
+ */
 export const chunk_sample_material_data = CodeChunk.from(
     //language=WGSL
     `
@@ -139,7 +147,8 @@ fn sample_material_data(
     material:${INDIRECT_MATERIAL_STRUCT.wgsl_ref},
     triangle:${TRIANGLE_VERTICES_STRUCT.wgsl_ref},
     lambda: vec3<f32>,
-    instance_transform: mat4x4<f32>, 
+    instance_transform: mat4x4<f32>,
+    texture_level: f32,
 ) -> ${STANDARD_MATERIAL_DATA_STRUCT.wgsl_ref}{
 
     let vertex_0 = triangle.a;
@@ -165,10 +174,10 @@ fn sample_material_data(
         lambda
     );
     
-    var texture_sample_diffuse = indirect_sample_texture(material.texture_albedo, material.sampler_albedo, uv).rgba;
+    var texture_sample_diffuse = indirect_sample_texture(material.texture_albedo, material.sampler_albedo, uv, texture_level).rgba;
 
 
-    var texture_sample_orm = indirect_sample_texture(material.texture_orm, material.sampler_orm, uv).rgba;
+    var texture_sample_orm = indirect_sample_texture(material.texture_orm, material.sampler_orm, uv, texture_level).rgba;
 
     var geometry_normal = interpolate_attribute_3f32( 
         vertex_0.normal,
@@ -216,7 +225,7 @@ fn sample_material_data(
 
     let world_tangent_frame = build_orthonormal_matrix_nt(world_vertex_normal, vec4(world_tangent, tangent_handedness));
 
-    var normal_sample = indirect_sample_tangent_normal(material.texture_normal, material.sampler_normal, uv);
+    var normal_sample = indirect_sample_tangent_normal(material.texture_normal, material.sampler_normal, uv, texture_level);
     
     var output: ${STANDARD_MATERIAL_DATA_STRUCT.wgsl_ref};
     
@@ -238,7 +247,7 @@ fn sample_material_data(
      the encoding of one texture, and this is the renderer the other is compared against.
     */
     let dithered_diffuse_sample = max(vec3(0.0), albedo_unpremultiply(texture_sample_diffuse) + (random_vec3() - 0.5 ) * bit_step);
-    let texture_sample_emissive = max(vec3(0.0), indirect_sample_texture(material.texture_emissive, material.sampler_emissive, uv).rgb + (random_vec3() - 0.5 ) * bit_step);
+    let texture_sample_emissive = max(vec3(0.0), indirect_sample_texture(material.texture_emissive, material.sampler_emissive, uv, texture_level).rgb + (random_vec3() - 0.5 ) * bit_step);
 
 
     output.albedo = dithered_diffuse_sample * material.color_albedo.rgb * geometry_color;

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

@@ -88,6 +88,10 @@ export class GPUSceneContext {
      * @returns {VGeoFeedbackLoop|undefined}
      */
     get virtual_geometry_feedback(): VGeoFeedbackLoop;
+    /**
+     * @returns {VGeoSDFProxies|undefined}
+     */
+    get virtual_geometry_proxies(): VGeoSDFProxies;
     /**
      * Give this scene a virtual-geometry runtime, sharing the meshlet pool with everything else it
      * draws.
@@ -101,7 +105,8 @@ export class GPUSceneContext {
      * (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.
+     * of it. With them, the source of its geometries' caches ({@link VGeoSDFProxies}): a cache asked
+     * of a virtual geometry is baked from a proxy cut from it.
      *
      * @param {Object} [options] passed to {@link GPUVirtualGeometryPool} and
      *     {@link GPUVirtualGeometryRuntime}, except for `residency`
@@ -252,6 +257,7 @@ import { GPUInstancesAccelerationStructure } from "./GPUInstancesAccelerationStr
 import { GPUVirtualGeometryRuntime } from "../geometry/virtual/runtime/GPUVirtualGeometryRuntime.js";
 import { VGeoResidency } from "../geometry/virtual/runtime/VGeoResidency.js";
 import { VGeoFeedbackLoop } from "../geometry/virtual/runtime/VGeoFeedbackLoop.js";
+import { VGeoSDFProxies } from "../geometry/virtual/sdf/VGeoSDFProxies.js";
 import { VGeoResidencyOptions } from "../geometry/virtual/runtime/VGeoResidencyOptions.js";
 import { GPUAnimationManager } from "../animation/GPUAnimationManager.js";
 import { GPUDatabase } from "../buffer/table/GPUDatabase.js";

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":"AA2EA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA2KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IArND;;;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;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAmID;;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,QA2BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAt0BY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,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;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAjBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AA4EA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA2KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IArND;;;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;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA0ID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,+CAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CA4DrC;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,QA2BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAwCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA91BY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,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;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAlBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;+BAInD,2CAA2C;qCADrC,qDAAqD;oCAItD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}

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

@@ -5,6 +5,7 @@ import { VGeoFeedbackLoop } from "../geometry/virtual/runtime/VGeoFeedbackLoop.j
 import { VGeoPageFetcher } from "../geometry/virtual/runtime/VGeoPageFetcher.js";
 import { VGeoResidency } from "../geometry/virtual/runtime/VGeoResidency.js";
 import { VGeoResidencyOptions } from "../geometry/virtual/runtime/VGeoResidencyOptions.js";
+import { VGeoSDFProxies } from "../geometry/virtual/sdf/VGeoSDFProxies.js";
 import { assert } from "../../../core/assert.js";
 import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
 import { GPUAnimationManager } from "../animation/GPUAnimationManager.js";
@@ -350,6 +351,13 @@ export class GPUSceneContext {
      */
     #virtual_geometry_fetcher;
 
+    /**
+     * What makes the virtual geometries' caches, a source of the geometry caches, once
+     * {@link enable_virtual_geometry} has run.
+     * @type {VGeoSDFProxies|undefined}
+     */
+    #virtual_geometry_proxies;
+
     /**
      * @returns {GPUVirtualGeometryRuntime|undefined}
      */
@@ -371,6 +379,13 @@ export class GPUSceneContext {
         return this.#virtual_geometry_feedback;
     }
 
+    /**
+     * @returns {VGeoSDFProxies|undefined}
+     */
+    get virtual_geometry_proxies() {
+        return this.#virtual_geometry_proxies;
+    }
+
     /**
      * Give this scene a virtual-geometry runtime, sharing the meshlet pool with everything else it
      * draws.
@@ -384,7 +399,8 @@ export class GPUSceneContext {
      * (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.
+     * of it. With them, the source of its geometries' caches ({@link VGeoSDFProxies}): a cache asked
+     * of a virtual geometry is baked from a proxy cut from it.
      *
      * @param {Object} [options] passed to {@link GPUVirtualGeometryPool} and
      *     {@link GPUVirtualGeometryRuntime}, except for `residency`
@@ -413,6 +429,7 @@ export class GPUSceneContext {
         let fetcher;
         let tiers;
         let feedback;
+        let proxies;
 
         try {
             runtime = new GPUVirtualGeometryRuntime({
@@ -430,6 +447,9 @@ export class GPUSceneContext {
             tiers = new VGeoResidency({ pool, options: residency, fetcher });
 
             feedback = new VGeoFeedbackLoop({ runtime, residency: tiers });
+
+            // last: it makes its buffers and subscribes to the caches as it is made
+            proxies = new VGeoSDFProxies({ device: this.#device, runtime, geometries: this.geometries });
         } 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
@@ -442,6 +462,7 @@ export class GPUSceneContext {
         this.#virtual_geometry_fetcher = fetcher;
         this.#virtual_geometry_residency = tiers;
         this.#virtual_geometry_feedback = feedback;
+        this.#virtual_geometry_proxies = proxies;
 
         return runtime;
     }
@@ -853,6 +874,9 @@ export class GPUSceneContext {
             return;
         }
 
+        // its proxies out of the geometry manager, and its cut's buffers, ahead of the runtime's
+        this.#virtual_geometry_proxies.destroy();
+
         this.#virtual_geometry_feedback.destroy();
 
         // gives back every container's rows and slots, and cancels what they had on the wire
@@ -867,6 +891,7 @@ export class GPUSceneContext {
         this.#virtual_geometry_residency = undefined;
         this.#virtual_geometry_feedback = undefined;
         this.#virtual_geometry_fetcher = undefined;
+        this.#virtual_geometry_proxies = undefined;
     }
 
 }

package/src/shade/renderer/shader/chunk/bvh/chunk_bvh_query_aabb_cooperative.d.ts

@@ -67,13 +67,13 @@
  *
  * ## Subgroups
  *
- * Appends are aggregated per subgroup: an exclusive add numbers the subgroup's appends, one elected
- * invocation reserves them all with one workgroup `atomicAdd`, and a broadcast hands each
- * invocation its base. Nothing assumes which invocations share a subgroup or that a subgroup's
- * invocations are contiguous in `local_invocation_index`: a subgroup reserves a run of its own
- * wherever it lands. Every subgroup operation is reached in uniform control flow; the loops' trip
- * counts are literals, and the one early exit is on a value read back through
- * `workgroupUniformLoad`.
+ * Appends are aggregated per subgroup (`chunk_subgroup_reserve_workgroup`): an exclusive add numbers
+ * the subgroup's appends, one elected invocation reserves them all with one workgroup `atomicAdd`,
+ * and a broadcast hands each invocation its base. Nothing assumes which invocations share a
+ * subgroup or that a subgroup's invocations are contiguous in `local_invocation_index`: a subgroup
+ * reserves a run of its own wherever it lands. Every subgroup operation is reached in uniform
+ * control flow; the loops' trip counts are literals, and the one early exit is on a value read
+ * back through `workgroupUniformLoad`.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/bvh/chunk_bvh_query_aabb_cooperative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_bvh_query_aabb_cooperative.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/bvh/chunk_bvh_query_aabb_cooperative.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,+CAFU,SAAS,CA+MhB;0BAlSuB,6BAA6B"}
+{"version":3,"file":"chunk_bvh_query_aabb_cooperative.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/bvh/chunk_bvh_query_aabb_cooperative.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,+CAFU,SAAS,CA8KhB;0BAlQuB,6BAA6B"}