@woosh/meep-engine 3.32.0 → 3.34.0

package/src/shade/renderer/GraphicsContext.d.ts

@@ -111,6 +111,17 @@ export class GraphicsContext {
         offset: number;
         size: number;
     }): void;
+    /**
+     * Set one bind group of `pipeline`'s layout, leaving the others as they are — for a pass whose
+     * groups change at different rates, where {@link setPipelineBindings} would set every group up
+     * to the last one on each change.
+     *
+     * @param {GPUBindingCommandsMixin} pass
+     * @param {PipelineDescriptorBase} pipeline
+     * @param {number} index the group's index in the pipeline's layout
+     * @param {GPUBindingResource[]} resources the group's entries, in binding order
+     */
+    setPipelineBindGroup(pass: GPUBindingCommandsMixin, pipeline: PipelineDescriptorBase, index: number, resources: GPUBindingResource[]): void;
     /**
      *
      * @param {BufferDescriptor} buffer_descriptor
@@ -123,6 +134,13 @@ export class GraphicsContext {
     get gpu_memory_usage(): number;
     initialize(): Promise<void>;
     update(): void;
+    /**
+     * Release what this context holds on the device: the texture cache and the mipmap generator,
+     * the materials, the geometry manager — the meshlet arena every scene shares, the geometry table
+     * and the BLAS — the buffer pools and the texture pool. The scene contexts go first, because a
+     * scene gives its skinned clones back to the geometry manager; `Renderer.destroy()` keeps that
+     * order.
+     */
     destroy(): void;
     /**
      * @readonly

package/src/shade/renderer/GraphicsContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAmCA;IAoKI,yBAiCC;IApMD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;;OAIG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;;OAIG;IACH,2BAFU,0BAA0B,CAEV;IAE1B;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAOC;IAED;;;OAGG;IACH,wBAEC;IAqCD;;;;;;;;OAQG;IACH,6DANW,sBAAsB,aACtB,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QAmE9D;IAED;;;;OAIG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAgBC;IAED,4BAEC;IAED,eAmDC;IAED,gBAoBC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BAvYY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAjBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAbzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAgBhD,6BAA6B;sCACtB,4CAA4C;iCAfjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAGrC,uCAAuC;yCACxC,sCAAsC;2CAFpC,wCAAwC;oCAS/C,kCAAkC;iCAVtB,8BAA8B"}
+{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAmCA;IAqKI,yBAiCC;IArMD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;;OAIG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;;OAIG;IACH,2BAFU,0BAA0B,CAEV;IAE1B;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAQC;IAED;;;OAGG;IACH,wBAEC;IAqCD;;;;;;;;OAQG;IACH,6DANW,sBAAsB,aACtB,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QA2B9D;IAED;;;;;;;;;OASG;IACH,8DAJW,sBAAsB,SACtB,MAAM,aACN,oBAAoB,QA0C9B;IAED;;;;OAIG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAgBC;IAED,4BAEC;IAED,eAoDC;IAED;;;;;;OAMG;IACH,gBAsBC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BA9ZY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAjBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAbzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAgBhD,6BAA6B;sCACtB,4CAA4C;iCAfjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAGrC,uCAAuC;yCACxC,sCAAsC;2CAFpC,wCAAwC;oCAS/C,kCAAkC;iCAVtB,8BAA8B"}

package/src/shade/renderer/GraphicsContext.js

@@ -183,8 +183,9 @@ export class GraphicsContext {
     increment_time() {
         this.#timer_increment++;
 
-        // advance the single frame clock for the substitutable pools in lockstep
+        // advance the single frame clock for the pools in lockstep
         this.buffer_allocator_main.increment_time();
+        this.buffer_allocator_staging.increment_time();
         this.buffer_allocator_upload.increment_time();
         this.allocator_textures.increment_time();
     }
@@ -257,53 +258,65 @@ export class GraphicsContext {
             pass.setImmediates(0, immediate.buffer.raw_bytes, immediate.offset, immediate.size);
         }
 
-        const bind_group_descriptors = pipeline.layout.bindGroupLayouts;
-
         const bind_group_count = bindings.length;
 
-        assert.lessThanOrEqual(bind_group_count, bind_group_descriptors.length, 'too many bind groups (more than in descriptor)');
-
-        const bind_group_manager = this.bind_groups;
+        assert.lessThanOrEqual(bind_group_count, pipeline.layout.bindGroupLayouts.length, 'too many bind groups (more than in descriptor)');
 
         for (let i = 0; i < bind_group_count; i++) {
-            const group_resource_set = bindings[i];
-
-            assert.isArray(group_resource_set, `bindings[${i}]`);
-
-            const bind_group_layout_descriptor = bind_group_descriptors[i];
-
-            const descriptor = BindGroupDescriptor.from(
-                bind_group_layout_descriptor,
-                group_resource_set
-            );
-
-            const bind_group = bind_group_manager.obtain(descriptor);
+            this.setPipelineBindGroup(pass, pipeline, i, bindings[i]);
+        }
+    }
 
-            if (DEBUG_LOGGING) {
-                // debug
-                const descriptor_rev = bind_group_manager.reverse_lookup(bind_group);
+    /**
+     * Set one bind group of `pipeline`'s layout, leaving the others as they are — for a pass whose
+     * groups change at different rates, where {@link setPipelineBindings} would set every group up
+     * to the last one on each change.
+     *
+     * @param {GPUBindingCommandsMixin} pass
+     * @param {PipelineDescriptorBase} pipeline
+     * @param {number} index the group's index in the pipeline's layout
+     * @param {GPUBindingResource[]} resources the group's entries, in binding order
+     */
+    setPipelineBindGroup(pass, pipeline, index, resources) {
+        assert.isArray(resources, `bindings[${index}]`);
 
-                const entries = descriptor_rev.entries
-                    .map(e => {
-                        if (e.buffer !== undefined) {
-                            return `buffer:"${e.buffer.label}"`;
-                        } else if (e instanceof GPUTextureView) {
-                            return "texture_view"
-                        } else if (e instanceof GPUSampler) {
-                            return "sampler"
-                        } else {
-                            // something else
-                            return "unknown";
-                        }
+        const bind_group_descriptors = pipeline.layout.bindGroupLayouts;
 
-                    })
-                    .filter(e => e !== undefined);
+        assert.lessThan(index, bind_group_descriptors.length, 'index is past the last group in the descriptor');
 
-                console.log(`pass.setBindGrpup(${i}, [ ${entries.join(', ')} ])`);
-            }
+        const bind_group_manager = this.bind_groups;
 
-            pass.setBindGroup(i, bind_group);
+        const descriptor = BindGroupDescriptor.from(
+            bind_group_descriptors[index],
+            resources
+        );
+
+        const bind_group = bind_group_manager.obtain(descriptor);
+
+        if (DEBUG_LOGGING) {
+            // debug
+            const descriptor_rev = bind_group_manager.reverse_lookup(bind_group);
+
+            const entries = descriptor_rev.entries
+                .map(e => {
+                    if (e.buffer !== undefined) {
+                        return `buffer:"${e.buffer.label}"`;
+                    } else if (e instanceof GPUTextureView) {
+                        return "texture_view"
+                    } else if (e instanceof GPUSampler) {
+                        return "sampler"
+                    } else {
+                        // something else
+                        return "unknown";
+                    }
+
+                })
+                .filter(e => e !== undefined);
+
+            console.log(`pass.setBindGrpup(${index}, [ ${entries.join(', ')} ])`);
         }
+
+        pass.setBindGroup(index, bind_group);
     }
 
     /**
@@ -390,12 +403,18 @@ export class GraphicsContext {
         }
 
         this.buffer_allocator_main.update();
+        this.buffer_allocator_staging.update();
         this.buffer_allocator_upload.update();
     }
 
+    /**
+     * Release what this context holds on the device: the texture cache and the mipmap generator,
+     * the materials, the geometry manager — the meshlet arena every scene shares, the geometry table
+     * and the BLAS — the buffer pools and the texture pool. The scene contexts go first, because a
+     * scene gives its skinned clones back to the geometry manager; `Renderer.destroy()` keeps that
+     * order.
+     */
     destroy() {
-        // TODO implement
-
         this.textures.destroy();
 
         this.virtual_textures.destroy();
@@ -406,12 +425,16 @@ export class GraphicsContext {
             this.#materials_resident.destroy();
         }
 
+        this.geometries.destroy();
+
         this.buffer_allocator_main.destroy();
         this.buffer_allocator_native.destroy();
         this.buffer_allocator_staging.destroy();
         this.buffer_allocator_upload.destroy();
         this.buffer_allocator_readback.destroy();
 
+        this.allocator_textures.destroy();
+
         this.#collection_limits.destroy();
     }
 }

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA8GA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,wCAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD;;;;;;;OAOG;IACH,mBAFU,qBAAqB,CAEkB;IAEjD;;;OAGG;IACH,QAFU,cAAc,CAEM;IAE9B;;;;;;;;;OASG;IACH,2BAFU,OAAO,CAEiB;IAElC,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAW1C,oCAIC;IAED,mCAEC;IAED,+BAA6B;IAC7B,4CAA0C;IAkB1C,qCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,oCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B;;;;;;;;;;OAUG;IACH,qBAA+B;IAgB/B;;;OAGG;IACH,yCAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,+BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,iBAAiB,GAAC,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,yBAHW,eAAe,GACb,eAAe,CAI3B;IAED;;;;;OAKG;IACH,4BAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAUD;;;;;;;;;;;;;;;;;OAiBG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAsB7B;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAYnB;IAED;;OAEG;IACH,8BAFa,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,yBAHW,KAAK,GACJ,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,gCAHW,KAAK,GACH,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,kBAFW,KAAK,QAyBf;IA8OD,oGAAoG;IACpG,kDAA2C;IAO3C;;;;OAIG;IACH,0BAEC;IAiBD;;;;;;OAMG;IACH,qBAHW,eAAe,GACb,iBAAiB,CAW7B;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;;OAMG;IACH;QAJsC,OAAO;QACd,MAAM;QACT,UAAU,GAA3B,MAAM;sBAoOhB;IAUD;;;;;;;;;;;;;;;;;OAiBG;IACH,WAFa,IAAI,CAuChB;IAgCD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;;;;;;OAeG;IACH,eAVW,iBAAiB,SACjB,KAAK,uBACL,MAAM,GAIJ,OAAO,CAyBnB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBARW,iBAAiB,SACjB,KAAK,sBACL,MAAM,UACN,iBAAiB,GACf,OAAO,CAiBnB;;CAs+BJ;+BAj0FY,OAAO,8CAA8C,EAAE,gBAAgB;gCACvE,OAAO,+CAA+C,EAAE,iBAAiB;gCACzE,OAAO,+BAA+B,EAAE,iBAAiB;8BACzD,OAAO,gCAAgC,EAAE,eAAe;gCACxD,OAAO,gDAAgD,EAAE,iBAAiB;8BAC1E,OAAO,4BAA4B,EAAE,eAAe;oBACpD,OAAO,kBAAkB,EAAE,KAAK;6BAvBhB,yBAAyB;0CACZ,gCAAgC;sCACpC,4BAA4B;+BACnC,6CAA6C;2BA1BjD,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAwC7C,uBAAuB;gCA7CnB,sBAAsB;oBApClC,4BAA4B;kCA8Ed,gCAAgC;2BA3DvC,2BAA2B;iCAyDrB,0CAA0C;4CA3C/B,+DAA+D;yBAgClF,yBAAyB;kCAChB,kCAAkC;kCAQlC,wBAAwB;oBA7BtC,0BAA0B;uCAPP,sDAAsD"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA8GA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,wCAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD;;;;;;;OAOG;IACH,mBAFU,qBAAqB,CAEkB;IAEjD;;;OAGG;IACH,QAFU,cAAc,CAEM;IAE9B;;;;;;;;;OASG;IACH,2BAFU,OAAO,CAEiB;IAElC,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAW1C,oCAIC;IAED,mCAEC;IAED,+BAA6B;IAC7B,4CAA0C;IAkB1C,qCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,oCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B;;;;;;;;;;OAUG;IACH,qBAA+B;IAgB/B;;;OAGG;IACH,yCAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,+BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,iBAAiB,GAAC,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,yBAHW,eAAe,GACb,eAAe,CAI3B;IAED;;;;;OAKG;IACH,4BAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAUD;;;;;;;;;;;;;;;;;OAiBG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAsB7B;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAYnB;IAED;;OAEG;IACH,8BAFa,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,yBAHW,KAAK,GACJ,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,gCAHW,KAAK,GACH,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,kBAFW,KAAK,QAyBf;IA8OD,oGAAoG;IACpG,kDAA2C;IAO3C;;;;OAIG;IACH,0BAEC;IAiBD;;;;;;OAMG;IACH,qBAHW,eAAe,GACb,iBAAiB,CAW7B;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;;OAMG;IACH;QAJsC,OAAO;QACd,MAAM;QACT,UAAU,GAA3B,MAAM;sBAoOhB;IAUD;;;;;;;;;;;;;;;;;OAiBG;IACH,WAFa,IAAI,CAuChB;IAgCD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;;;;;;OAeG;IACH,eAVW,iBAAiB,SACjB,KAAK,uBACL,MAAM,GAIJ,OAAO,CAyBnB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBARW,iBAAiB,SACjB,KAAK,sBACL,MAAM,UACN,iBAAiB,GACf,OAAO,CAiBnB;;CA4gCJ;+BAv2FY,OAAO,8CAA8C,EAAE,gBAAgB;gCACvE,OAAO,+CAA+C,EAAE,iBAAiB;gCACzE,OAAO,+BAA+B,EAAE,iBAAiB;8BACzD,OAAO,gCAAgC,EAAE,eAAe;gCACxD,OAAO,gDAAgD,EAAE,iBAAiB;8BAC1E,OAAO,4BAA4B,EAAE,eAAe;oBACpD,OAAO,kBAAkB,EAAE,KAAK;6BAvBhB,yBAAyB;0CACZ,gCAAgC;sCACpC,4BAA4B;+BACnC,6CAA6C;2BA1BjD,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAwC7C,uBAAuB;gCA7CnB,sBAAsB;oBApClC,4BAA4B;kCA8Ed,gCAAgC;2BA3DvC,2BAA2B;iCAyDrB,0CAA0C;4CA3C/B,+DAA+D;yBAgClF,yBAAyB;kCAChB,kCAAkC;kCAQlC,wBAAwB;oBA7BtC,0BAA0B;uCAPP,sDAAsD"}

package/src/shade/renderer/Renderer.js

@@ -1994,6 +1994,14 @@ export class Renderer {
      */
     #frame_profile_session = null;
 
+    /**
+     * The virtual-geometry runtime whose frame the frame in {@link #frame_command_ctx} opened, and
+     * null otherwise — so a frame that throws before closing it still closes it.
+     *
+     * @type {import("./geometry/virtual/runtime/GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime|null}
+     */
+    #frame_virtual_geometry = null;
+
     /**
      * Finish the context a frame left behind when it threw before its teardown: the scene tick, the
      * shadow draw and every extension phase run between the context's creation and the teardown,
@@ -2014,6 +2022,10 @@ export class Renderer {
         this.#frame_profile_recorder = null;
         this.#frame_profile_session = null;
 
+        // a frame that threw between opening virtual geometry and closing it leaves it closed
+        this.#frame_virtual_geometry?.end_frame();
+        this.#frame_virtual_geometry = null;
+
         if (stranded === null) {
             return;
         }
@@ -2148,6 +2160,23 @@ export class Renderer {
         // culling samples it. No-op when nothing's registered.
         view_ctx.scene.tick(command_ctx, time_delta_seconds);
 
+        /*
+         The virtual-geometry frame, which spans every graph this render records: the shadow maps
+         draw into graphs of their own before the `Shading` graph exists, and a shadow view cuts like
+         any other view (SHADOW_PLAN_2026_09_28). So it opens here — before the shadow block and
+         outside its `if`, so a frame with shadows off still opens and closes — for the view this
+         frame is rendered for, which takes the feedback's first slot. The readback is recorded into
+         the `Shading` graph once everything has cut, and the frame is closed whether or not the
+         frame gets that far.
+        */
+        const virtual_geometry = view_ctx.scene.virtual_geometry;
+
+        if (virtual_geometry !== undefined) {
+            virtual_geometry.begin_frame({ view: view_ctx.virtual_geometry_cut });
+
+            this.#frame_virtual_geometry = virtual_geometry;
+        }
+
         const viz_rt = this.#vis_render_target;
 
         // prepare shadows (process_lights already ran inside lights.update via view_ctx.update,
@@ -2895,6 +2924,11 @@ export class Renderer {
 
         this.#extensions.run(frame);
 
+        if (virtual_geometry !== undefined) {
+            // every view of the frame has cut by now, shadow maps included; read while recording
+            view_ctx.scene.virtual_geometry_feedback.read(graph);
+        }
+
         frame.close();
 
         if (profile_recorder !== null) {
@@ -2919,6 +2953,10 @@ export class Renderer {
             frame_error = e;
         }
 
+        // nothing records after the `Shading` graph, so nothing may cut
+        this.#frame_virtual_geometry = null;
+        virtual_geometry?.end_frame();
+
         /*
          `finish()` is what resolves `profiling_absorbed`, destroys this frame's query set and its
          resolve/readback buffers, and — through the block below — lets the recorder drop the

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.d.ts

@@ -188,6 +188,14 @@ export class GPUMeshSkinningContext {
      * its bounds, moved this frame
      */
     update(cmd_ctx: ShadeGPUCommandContext): boolean;
+    /**
+     * Release this context's buffers, and give back what it holds in the shared geometry manager,
+     * which outlives it: every clone's vertex region, and every binding's watch on the batch records
+     * it follows — a source's record is the manager's, and would go on announcing its moves to a
+     * context that is gone. For the scene context's teardown, after its tables are destroyed: no
+     * mesh row names a clone by then, and the bindings go here, so each clone is named by nothing
+     * when it is given back.
+     */
     destroy(): void;
     #private;
 }

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAUhB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA0NnB;IAkXD,gBAkBC;;CACJ;qCA1vCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}
+{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,4BAFW,MAAM,QAUhB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA0NnB;IAkXD;;;;;;;OAOG;IACH,gBA+BC;;CACJ;qCA/wCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js

@@ -1284,7 +1284,28 @@ export class GPUMeshSkinningContext {
         this.#device.queue.writeBuffer(this.#dispatch_lookup_buffer, 0, data);
     }
 
+    /**
+     * Release this context's buffers, and give back what it holds in the shared geometry manager,
+     * which outlives it: every clone's vertex region, and every binding's watch on the batch records
+     * it follows — a source's record is the manager's, and would go on announcing its moves to a
+     * context that is gone. For the scene context's teardown, after its tables are destroyed: no
+     * mesh row names a clone by then, and the bindings go here, so each clone is named by nothing
+     * when it is given back.
+     */
     destroy() {
+        for (const binding of this.#bindings) {
+            binding.unfollow();
+        }
+
+        this.#bindings.length = 0;
+        this.#total_meshlet_count = 0;
+
+        for (const { clone } of this.#clones.values()) {
+            this.#geometries.remove_clone(clone);
+        }
+
+        this.#clones.clear();
+
         if (this.#bindings_buffer !== null) {
             this.#bindings_buffer.destroy();
             this.#bindings_buffer = null;

package/src/shade/renderer/buffer/GPUBufferReadbackAllocator.d.ts

@@ -2,11 +2,12 @@
  * Persistent `MAP_READ | COPY_DST` buffers for reading GPU data back — {@link GPUBufferStagingAllocator}
  * run the other way.
  *
- * The same shape on purpose: a size-sorted free list, `get(min_size)` serving the smallest buffer
- * that fits and creating one when none does, `release(buffer)` putting it back. Where the staging
- * pool re-maps a buffer on release because the next writer needs it mapped, this one *unmaps*,
- * because the next copy into it needs it unmapped; the mapping is the holder's, taken after the
- * copy has landed and read at the holder's own apply point.
+ * The same shape: a size-sorted free list, `get(min_size)` serving the smallest buffer that fits
+ * and creating one when none does, `release(buffer)` putting it back. Where the staging pool re-maps
+ * a buffer on release because the next writer needs it mapped, this one *unmaps*, because the next
+ * copy into it needs it unmapped; the mapping is the holder's, taken after the copy has landed and
+ * read at the holder's own apply point. Unlike the staging pool, this one has no bound on how much
+ * larger than the request a buffer it serves may be, no size classes and no reclaim.
  *
  * Why not `buffer_allocator_main`: `TransientResourcePool`'s reuse safety rests on transients being
  * GPU-only, and a readback buffer is held by the CPU across frames.

package/src/shade/renderer/buffer/GPUBufferReadbackAllocator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUBufferReadbackAllocator.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/GPUBufferReadbackAllocator.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA4BI;;;;OAIG;IACH;QAF4B,YAAY,GAA7B,MAAM;OAQhB;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,0BAEC;IAED;;;;;;OAMG;IACH,oBAHW,MAAM,aAkChB;IAED;;;;;OAKG;IACH,iCAsBC;IAED;;;;;OAKG;IACH,iCAMC;IAkBD,gBAUC;;CACJ"}
+{"version":3,"file":"GPUBufferReadbackAllocator.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/GPUBufferReadbackAllocator.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA4BI;;;;OAIG;IACH;QAF4B,YAAY,GAA7B,MAAM;OAQhB;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,0BAEC;IAED;;;;;;OAMG;IACH,oBAHW,MAAM,aAkChB;IAED;;;;;OAKG;IACH,iCAsBC;IAED;;;;;OAKG;IACH,iCAMC;IAkBD,gBAUC;;CACJ"}