@woosh/meep-engine 3.58.0 → 3.60.0

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

@@ -4,6 +4,7 @@ import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js"
 import { SHADING_LIGHT_RESOURCE_GROUP } from "../../../deferred/SHADING_LIGHT_RESOURCE_GROUP.js";
 import { DEPTH_BACKGROUND_VALUE } from "../../../depth/DEPTH_BACKGROUND_VALUE.js";
 import { BRICK4_DATA_STRUCT } from "../../../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
+import { PROBE_CLIPMAP_SAMPLING_GROUP } from "../../../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js";
 import { STANDARD_MATERIAL_TEMPLATE } from "../../../material/standard/STANDARD_MATERIAL_TEMPLATE.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { RenderPassColorAttachmentDescriptor } from "../../../shader/pass/RenderPassColorAttachmentDescriptor.js";
@@ -31,7 +32,8 @@ import {
 
 /**
  * The draw's own group, group 2: the view, the AVBOIT volume, and what every indirect lighting mode
- * reads (`brick4`; `tEnvironment` is the lights'). The orchestrator binds it by name.
+ * reads (`brick4`, the probe clipmap's probes; `tEnvironment` is the lights'). The orchestrator binds it
+ * by name.
  *
  * @type {ShaderResourceGroupDescriptor}
  */
@@ -52,12 +54,26 @@ AVBOIT_DRAW_VIEW_GROUP
     .addTexture("tVolumetrics", "float", "3d")
     .addTexture("tSTBN_vec3", "float", "3d")
 
+// the probes, read under the probe clipmap's indirect lighting; their owner binds them in every mode
+for (const declaration of PROBE_CLIPMAP_SAMPLING_GROUP.resources) {
+    AVBOIT_DRAW_VIEW_GROUP.add(declaration);
+}
+
 const pass_groups = [AVBOIT_DRAW_VIEW_GROUP, SHADING_LIGHT_RESOURCE_GROUP];
 
 // the view group keeps the visibility the orchestrator builds its bind group for, as the vertex stage
-// reads the camera from it; the lights are the fragment stage's alone
+// reads the camera from it, but for the probes; they and the lights are the fragment stage's alone, which
+// keeps the vertex stage at 8 storage buffers of the 10 a device is asked for
+const view_layout = AVBOIT_DRAW_VIEW_GROUP.generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT);
+
+for (const declaration of PROBE_CLIPMAP_SAMPLING_GROUP.resources) {
+    const binding = AVBOIT_DRAW_VIEW_GROUP.get(declaration.name).binding_index;
+
+    view_layout.entries.find(entry => entry.binding === binding).visibility = GPUShaderStage.FRAGMENT;
+}
+
 const pass_layouts = [
-    AVBOIT_DRAW_VIEW_GROUP.generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    view_layout,
     FORWARD_LIGHT_LAYOUT,
 ];
 

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

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

package/src/shade/renderer/rasterize/native/graph_rasterize_meshes_alpha_tested.js

@@ -140,7 +140,9 @@ export function graph_rasterize_meshes_alpha_tested({
         const partial_clear_needed = !is_viewport_unrestricted && clear_target;
 
         if (partial_clear_needed) {
-            // TODO clear color targets
+            for (let i = 0; i < color_targets.length; i++) {
+                texture_fill_rectangle(encoder, color_targets[i], viewport, render_pass_descriptor.colorAttachments[i].clearValue);
+            }
             texture_fill_rectangle(encoder, depth_texture, viewport, [render_pass_descriptor.depthStencilAttachment.depthClearValue]);
         }
 
@@ -149,7 +151,7 @@ export function graph_rasterize_meshes_alpha_tested({
         const gpu_pass_descriptor = render_pass_descriptor.toGPU({
             colorTargets: color_targets,
             depthTarget: depth_texture,
-            loadOp: clear_target ? "clear" : "load",
+            loadOp: !partial_clear_needed && clear_target ? "clear" : "load",
         });
 
         const pass_encoder = encoder.beginRenderPass(gpu_pass_descriptor);

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.d.ts

@@ -14,7 +14,9 @@
  * @param {number} shadowmap_atlas
  * @param {ShaderSwitchSet} [shader_switches] the renderer's; the resolve's pipelines are built for them, and
  *   the set is all the resolve needs to know of the indirect lighting mode
+ * @param {import("../../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} probes
+ *   the renderer's probe clipmap GI, whose probes the resolve binds in every mode
  * @returns {number} resource ID of modified color texture
  */
-export function graph_rasterize_meshes_transparent_oit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, shader_switches, }: FrameGraph): number;
+export function graph_rasterize_meshes_transparent_oit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, shader_switches, probes, }: FrameGraph): number;
 //# sourceMappingURL=graph_rasterize_meshes_transparent_oit.d.ts.map

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_oit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js"],"names":[],"mappings":"AA0YA;;;;;;;;;;;;;;;;;GAiBG;AACH,gSAFa,MAAM,CAyOlB"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_oit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js"],"names":[],"mappings":"AAiZA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wSAFa,MAAM,CA6OlB"}

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js

@@ -50,6 +50,8 @@ import { SHADING_SCENE_LAYOUT } from "../../forward/SHADING_SCENE_RESOURCE_GROUP
  * @param {number} output
  * @param {PrimitiveState} primitive
  * @param {ShaderSwitchSet} shader_switches the renderer's; the resolve's pipelines are built for them
+ * @param {import("../../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} probes
+ *   the renderer's probe clipmap GI, whose probes the resolve binds in every mode
  * @return {number}
  */
 function graph_oit_resolve_moments({
@@ -75,8 +77,10 @@ function graph_oit_resolve_moments({
 
                                        output = -1,
                                        shader_switches = ShaderSwitchSet.EMPTY,
+                                       probes,
                                    }) {
 
+    assert.defined(probes, 'probes');
     assert.isNonNegativeInteger(material_count, 'material_count');
     assert.isNonNegativeInteger(draw_commands, 'draw_commands');
     assert.isNonNegativeInteger(meshlets, 'meshlets');
@@ -169,22 +173,24 @@ function graph_oit_resolve_moments({
 
         const stbn_vec3 = graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3);
 
-        // by name: every indirect lighting mode's resources, whichever the pipeline's variant reads
+        // by name: every indirect lighting mode's resources, whichever the pipeline's variant reads; the
+        // probes, a clipmap of no cascade while the probe clipmap has none
+        const view_inputs = data.probes.write_sampling_bindings({
+            camera: view_ctx.camera.buffer.buffer,
+            view: view_ctx.uniform_buffer.buffer,
+            moments: t_moments,
+            optical_depth: t_optical_depth,
+            brick4: view_ctx.scene.volumetric_light_map.buffer,
+            tSplitSum: t_split_sum_lut,
+            sLinear: sampler_linear,
+            // volumetrics
+            volumetrics_metadata,
+            tVolumetrics: t_volumetrics_lut,
+            tSTBN_vec3: stbn_vec3,
+        });
         const view_bindings = bind_manager.obtain(BindGroupDescriptor.from(
             render_pass_descriptor.pipeline_layout.bindGroupLayouts[RASTERIZATION_SHADER_BIND_GROUP_VIEW],
-            OIT_RESOLVE_VIEW_GROUP.generateBindings({
-                camera: view_ctx.camera.buffer.buffer,
-                view: view_ctx.uniform_buffer.buffer,
-                moments: t_moments,
-                optical_depth: t_optical_depth,
-                brick4: view_ctx.scene.volumetric_light_map.buffer,
-                tSplitSum: t_split_sum_lut,
-                sLinear: sampler_linear,
-                // volumetrics
-                volumetrics_metadata,
-                tVolumetrics: t_volumetrics_lut,
-                tSTBN_vec3: stbn_vec3,
-            }, encoder)
+            OIT_RESOLVE_VIEW_GROUP.generateBindings(view_inputs, encoder)
         ));
 
         pass_encoder.setBindGroup(RASTERIZATION_SHADER_BIND_GROUP_VIEW, view_bindings);
@@ -206,6 +212,7 @@ function graph_oit_resolve_moments({
 
     const pass_data = {
         shader_switches,
+        probes,
     };
     const pass = graph.add("MBOIT/resolve moments", pass_data, execute);
 
@@ -408,6 +415,8 @@ function graph_oit_generate_moments({
  * @param {number} shadowmap_atlas
  * @param {ShaderSwitchSet} [shader_switches] the renderer's; the resolve's pipelines are built for them, and
  *   the set is all the resolve needs to know of the indirect lighting mode
+ * @param {import("../../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} probes
+ *   the renderer's probe clipmap GI, whose probes the resolve binds in every mode
  * @returns {number} resource ID of modified color texture
  */
 export function graph_rasterize_meshes_transparent_oit({
@@ -428,10 +437,12 @@ export function graph_rasterize_meshes_transparent_oit({
                                                            volumetrics_metadata,
 
                                                            shader_switches = ShaderSwitchSet.EMPTY,
+                                                           probes,
                                                        }) {
 
 
     assert.isNonNegativeInteger(buckets, 'buckets');
+    assert.defined(probes, 'probes');
 
     assert.isNonNegativeInteger(light_cluster_parameters, 'light_cluster_parameters');
     assert.isNonNegativeInteger(light_cluster_lookup, 'light_cluster_lookup');
@@ -598,6 +609,7 @@ export function graph_rasterize_meshes_transparent_oit({
         volumetrics_metadata,
 
         shader_switches,
+        probes,
     });
 
     resolved = graph_oit_resolve_moments({
@@ -625,6 +637,7 @@ export function graph_rasterize_meshes_transparent_oit({
         volumetrics_metadata,
 
         shader_switches,
+        probes,
     });
 
     const [blended] = graph_image_pass({

package/src/shade/renderer/rasterize/native/oit/shader_oit_resolve_moments.d.ts

@@ -1,6 +1,7 @@
 /**
  * The resolve's own group, group 2: the view, the moments, and what every indirect lighting mode
- * reads (`brick4`; `tEnvironment` is the lights'). The orchestrator binds it by name.
+ * reads (`brick4`, the probe clipmap's probes; `tEnvironment` is the lights'). The orchestrator binds it
+ * by name.
  *
  * @type {ShaderResourceGroupDescriptor}
  */

package/src/shade/renderer/rasterize/native/oit/shader_oit_resolve_moments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_oit_resolve_moments.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/shader_oit_resolve_moments.js"],"names":[],"mappings":"AA8BA;;;;;GAKG;AACH,qCAFU,6BAA6B,CAEmC;AA+B1E;;;;;;GAMG;AACH,yCAFU,sBAAsB,CAmC7B;8CA5F2C,2DAA2D;uCAIlE,iCAAiC"}
+{"version":3,"file":"shader_oit_resolve_moments.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/shader_oit_resolve_moments.js"],"names":[],"mappings":"AA+BA;;;;;;GAMG;AACH,qCAFU,6BAA6B,CAEmC;AA6C1E;;;;;;GAMG;AACH,yCAFU,sBAAsB,CAmC7B;8CA3G2C,2DAA2D;uCAIlE,iCAAiC"}

package/src/shade/renderer/rasterize/native/oit/shader_oit_resolve_moments.js

@@ -4,6 +4,7 @@ import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js"
 import { SHADING_LIGHT_RESOURCE_GROUP } from "../../../deferred/SHADING_LIGHT_RESOURCE_GROUP.js";
 import { DEPTH_BACKGROUND_VALUE } from "../../../depth/DEPTH_BACKGROUND_VALUE.js";
 import { BRICK4_DATA_STRUCT } from "../../../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
+import { PROBE_CLIPMAP_SAMPLING_GROUP } from "../../../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js";
 import { STANDARD_MATERIAL_TEMPLATE } from "../../../material/standard/STANDARD_MATERIAL_TEMPLATE.js";
 import { VOLUMETRICS_METADATA_STRUCT } from "../../../volumetrics/VOLUMETRICS_METADATA_STRUCT.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
@@ -30,7 +31,8 @@ import { vertex_shader_chunk } from "../../forward/vertex_shader_chunk.js";
 
 /**
  * The resolve's own group, group 2: the view, the moments, and what every indirect lighting mode
- * reads (`brick4`; `tEnvironment` is the lights'). The orchestrator binds it by name.
+ * reads (`brick4`, the probe clipmap's probes; `tEnvironment` is the lights'). The orchestrator binds it
+ * by name.
  *
  * @type {ShaderResourceGroupDescriptor}
  */
@@ -50,12 +52,26 @@ OIT_RESOLVE_VIEW_GROUP
     .addTexture("tVolumetrics", "float", "3d")
     .addTexture("tSTBN_vec3", "float", "3d")
 
+// the probes, read under the probe clipmap's indirect lighting; their owner binds them in every mode
+for (const declaration of PROBE_CLIPMAP_SAMPLING_GROUP.resources) {
+    OIT_RESOLVE_VIEW_GROUP.add(declaration);
+}
+
 const pass_groups = [OIT_RESOLVE_VIEW_GROUP, SHADING_LIGHT_RESOURCE_GROUP];
 
 // the view group keeps the visibility the orchestrator builds its bind group for, as the vertex stage
-// reads the camera from it; the lights are the fragment stage's alone
+// reads the camera from it, but for the probes; they and the lights are the fragment stage's alone, as
+// the AVBOIT draw keeps them
+const view_layout = OIT_RESOLVE_VIEW_GROUP.generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT);
+
+for (const declaration of PROBE_CLIPMAP_SAMPLING_GROUP.resources) {
+    const binding = OIT_RESOLVE_VIEW_GROUP.get(declaration.name).binding_index;
+
+    view_layout.entries.find(entry => entry.binding === binding).visibility = GPUShaderStage.FRAGMENT;
+}
+
 const pass_layouts = [
-    OIT_RESOLVE_VIEW_GROUP.generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    view_layout,
     FORWARD_LIGHT_LAYOUT,
 ];
 

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