@woosh/meep-engine 3.60.5 → 3.60.7

package/src/shade/renderer/geometry/sdf/cards/GPUMeshCardSets.js

@@ -125,7 +125,8 @@ function grow_typed(array, length) {
  * - Its record (`MESH_CARD_SET_STRUCT`) is written when a capture starts.
  *
  * **Lifetime.** {@link acquire} makes a card set for a pair and {@link release} gives it back; the
- * caller keeps one per pair. A card set waits until its geometry's layout is placed
+ * caller keeps one per pair. A card set of an aliased geometry ({@link alias}) is its source's: it
+ * captures the source's layout through the source's meshlets. A card set waits until its geometry's layout is placed
  * ({@link set_layout}), is then captured, and turns resident ({@link onResident}) on the frame its
  * last page is recorded: the capture's writes come before any later pass reads it. A layout that
  * goes ({@link drop_layout}) withdraws its card sets ({@link onWithdrawn}) back to waiting.
@@ -160,6 +161,12 @@ export class GPUMeshCardSets {
 
     #ids = new IdPool();
 
+    /**
+     * The source of each aliased geometry id.
+     * @type {Map<number, number>}
+     */
+    #source_of = new Map();
+
     // ---- per card set id ----
 
     #state = new Uint8Array(64);
@@ -479,7 +486,8 @@ export class GPUMeshCardSets {
     /**
      * A card set for a pair. The caller keeps one per pair.
      *
-     * @param {number} geometry the geometry id whose layout it captures: the source's, for a skinned row
+     * @param {number} geometry the geometry id the pair draws; an aliased one's card set captures its source's
+     *     layout ({@link alias})
      * @param {ShadeMaterial} material
      * @returns {number} card set id
      */
@@ -487,6 +495,8 @@ export class GPUMeshCardSets {
         assert.isNonNegativeInteger(geometry, 'geometry');
         assert.defined(material, 'material');
 
+        geometry = this.#source_of.get(geometry) ?? geometry;
+
         const id = this.#ids.get();
 
         this.#ensure_id(id);
@@ -635,6 +645,60 @@ export class GPUMeshCardSets {
         }
     }
 
+    /**
+     * The geometry `clone` is drawn as `source` from here on: its card sets, and those acquired for it after, capture
+     * `source`'s layout through `source`'s meshlets, the two being in one local space. A card set of `clone` waits
+     * for `source`'s layout, as one acquired for `source` does.
+     *
+     * @param {number} clone
+     * @param {number} source
+     */
+    alias(clone, source) {
+        assert.notEqual(clone, source, 'a geometry cannot alias itself');
+
+        this.#source_of.set(clone, source);
+
+        // its own layout, if it had one, went with its cache: what it has waits
+        this.drop_layout(clone);
+
+        const sets = this.#sets_of_geometry.get(clone);
+
+        if (sets === undefined) {
+            return;
+        }
+
+        this.#sets_of_geometry.delete(clone);
+
+        for (let i = 0; i < sets.length; i++) {
+            const id = sets[i];
+
+            this.#geometry[id] = source;
+
+            let of_source = this.#sets_of_geometry.get(source);
+
+            if (of_source === undefined) {
+                of_source = [];
+                this.#sets_of_geometry.set(source, of_source);
+            }
+
+            of_source.push(id);
+
+            if (this.#layout_pages.has(source)) {
+                this.#start(id);
+            }
+        }
+    }
+
+    /**
+     * `clone` is no longer aliased: card sets acquired for it from here on capture its own layout. Those it has keep
+     * capturing its source's until they are given back.
+     *
+     * @param {number} clone
+     */
+    unalias(clone) {
+        this.#source_of.delete(clone);
+    }
+
     /**
      * Pages from the atlas for a card set whose layout is placed, and its first capture queued.
      *

package/src/shade/renderer/geometry/virtual/proxy/vgeo_proxy_triangle_limit.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The triangles a virtual geometry's proxy is cut to by default: {@link VGEO_PROXY_TRIANGLE_SHARE} of the source's,
+ * at least one cluster's and at most {@link VGEO_PROXY_TRIANGLE_MAX}.
+ *
+ * @param {number} source_triangles
+ * @returns {number}
+ */
+export function vgeo_proxy_triangle_limit(source_triangles: number): number;
+/**
+ * The share of the source's triangles a proxy keeps by default.
+ * @type {number}
+ */
+export const VGEO_PROXY_TRIANGLE_SHARE: number;
+/**
+ * Most triangles a proxy has by default, however large the source.
+ * @type {number}
+ */
+export const VGEO_PROXY_TRIANGLE_MAX: number;
+//# sourceMappingURL=vgeo_proxy_triangle_limit.d.ts.map

package/src/shade/renderer/geometry/virtual/proxy/vgeo_proxy_triangle_limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_proxy_triangle_limit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/proxy/vgeo_proxy_triangle_limit.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,4DAHW,MAAM,GACJ,MAAM,CAIlB;AArBD;;;GAGG;AACH,wCAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,sCAFU,MAAM,CAE6B"}

package/src/shade/renderer/geometry/virtual/proxy/vgeo_proxy_triangle_limit.js

@@ -0,0 +1,25 @@
+import { clamp } from "../../../../../core/math/clamp.js";
+import { VGEO_MAX_CLUSTER_TRIANGLE_COUNT } from "../format/cluster/VGEO_MAX_CLUSTER_TRIANGLE_COUNT.js";
+
+/**
+ * The share of the source's triangles a proxy keeps by default.
+ * @type {number}
+ */
+export const VGEO_PROXY_TRIANGLE_SHARE = 0.01;
+
+/**
+ * Most triangles a proxy has by default, however large the source.
+ * @type {number}
+ */
+export const VGEO_PROXY_TRIANGLE_MAX = 64000;
+
+/**
+ * The triangles a virtual geometry's proxy is cut to by default: {@link VGEO_PROXY_TRIANGLE_SHARE} of the source's,
+ * at least one cluster's and at most {@link VGEO_PROXY_TRIANGLE_MAX}.
+ *
+ * @param {number} source_triangles
+ * @returns {number}
+ */
+export function vgeo_proxy_triangle_limit(source_triangles) {
+    return Math.floor(clamp(source_triangles * VGEO_PROXY_TRIANGLE_SHARE, VGEO_MAX_CLUSTER_TRIANGLE_COUNT, VGEO_PROXY_TRIANGLE_MAX));
+}

package/src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUVirtualGeometryRuntime.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAmHI;;;;;;;;;;;;;;;OAeG;IACH;QAd2C,IAAI,EAApC,sBAAsB;QACL,aAAa,GAA9B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QAEW,mBAAmB,GAApC,MAAM;QAEW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QAEW,qBAAqB,GAAtC,MAAM;QACW,aAAa,GAA9B,MAAM;OAgFhB;IA3KD;;;;OAIG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,OAAO,CAEG;IAmKpB;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;OAIG;IACH,gCAEC;IAWD;;;;;;OAMG;IACH,iCAKC;IArBD;;;;OAIG;IACH,4BAEC;IAgBD;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH;;;;;;;;MAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QAHgC,IAAI,EAAzB,WAAW;QACT,IAAI,CAqChB;IAwBD;;;;;;;;;;OAUG;IACH,cAHW,oBAAoB,GAClB,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,oCAHW,MAAM,OAkBhB;IAED;;;;;OAKG;IACH,eAFa,oBAAoB,EAAE,EAAE,CAIpC;IAED;;;;;;;;;OASG;IACH,mBAHW,UAAU,GACR,MAAM,CAkClB;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAJ2B,iBAAiB,EAAjC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACJ,IAAI,CAgBhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,aAFa,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAOhB;;CACJ;qCA/pBY,OAAO,6BAA6B,EAAE,sBAAsB;0BAC5D,OAAO,kBAAkB,EAAE,WAAW;yBACtC,OAAO,iEAAiE,EAAE,UAAU;;;;;;;;;;0BAQ1E,WAAW,QAAE,MAAM,QAAE,OAAO,QAAE,yBAAyB,KAAG,IAAI"}
+{"version":3,"file":"GPUVirtualGeometryRuntime.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAmHI;;;;;;;;;;;;;;;OAeG;IACH;QAd2C,IAAI,EAApC,sBAAsB;QACL,aAAa,GAA9B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QAEW,mBAAmB,GAApC,MAAM;QAEW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QAEW,qBAAqB,GAAtC,MAAM;QACW,aAAa,GAA9B,MAAM;OAgFhB;IA3KD;;;;OAIG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,OAAO,CAEG;IAmKpB;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;OAIG;IACH,gCAEC;IAWD;;;;;;OAMG;IACH,iCAKC;IArBD;;;;OAIG;IACH,4BAEC;IAgBD;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH;;;;;;;;MAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QAHgC,IAAI,EAAzB,WAAW;QACT,IAAI,CAqChB;IAwBD;;;;;;;;;;OAUG;IACH,cAHW,oBAAoB,GAClB,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,oCAHW,MAAM,OAkBhB;IAED;;;;;OAKG;IACH,eAFa,oBAAoB,EAAE,EAAE,CAIpC;IAED;;;;;;;;;OASG;IACH,mBAHW,UAAU,GACR,MAAM,CAkClB;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAJ2B,iBAAiB,EAAjC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACJ,IAAI,CAgBhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,aAFa,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAOhB;;CACJ;qCA/pBY,OAAO,6BAA6B,EAAE,sBAAsB;0BAC5D,OAAO,kBAAkB,EAAE,WAAW;yBACtC,OAAO,iEAAiE,EAAE,UAAU;;;;;;;;;;0BAQ1E,WAAW,QAAE,MAAM,QAAE,OAAO,QAAE,yBAAyB,KAAG,IAAI"}

package/src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js

@@ -6,6 +6,7 @@ import {
     vgeo_feedback_slot_want_count,
     vgeo_feedback_slot_wants
 } from "./cut/vgeo_cut_feedback_layout.js";
+import { ceilPowerOfTwo } from "../../../../../core/binary/operations/ceilPowerOfTwo.js";
 
 /**
  * @typedef {import("./GPUVirtualGeometryPool.js").GPUVirtualGeometryPool} GPUVirtualGeometryPool
@@ -449,7 +450,7 @@ export class GPUVirtualGeometryRuntime {
         existing?.destroy();
 
         // to the next power of two, so a tier filling a page row at a time re-makes it rarely
-        const size = Math.max(256, 2 ** Math.ceil(Math.log2(bytes)));
+        const size = Math.max(256, ceilPowerOfTwo(bytes));
 
         this.#feedback_buffer = this.#pool.device.createBuffer({
             label: 'vgeo feedback',

package/src/shade/renderer/geometry/virtual/runtime/VGeoResidency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGeoResidency.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoResidency.js"],"names":[],"mappings":"AA4GA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH;IAiKI;;;;;;;OAOG;IACH;QAN2C,IAAI,EAApC,sBAAsB;QACS,OAAO,GAAtC,oBAAoB;QACM,IAAI,GAA9B,eAAe;QACW,OAAO,GAAjC,eAAe;OA8BzB;IAID;;OAEG;IACH,oCAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,oBAEC;IAED;;;;OAIG;IACH,gCAGC;IAED,+BAEC;IAED,iCAEC;IAED,6BAEC;IAED,2BAEC;IAED,iCAEC;IAED,gCAEC;IAED;;;;OAIG;IACH,oCAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;OAGG;IACH,iCAEC;IAED,gCAEC;IAED,+BAEC;IAED,8BAEC;IAED;;OAEG;IACH,qCAQC;IAID;;;;;;;;;;OAUG;IACH,iBAHW,mBAAmB,GACjB,MAAM,CA8ClB;IAED;;;;;;OAMG;IACH,mBAHW,mBAAmB,GACjB,OAAO,CAgBnB;IAED;;;OAGG;IACH,sBAHW,mBAAmB,GACjB,OAAO,CAInB;IAED;;;;;;OAMG;IACH,cAJW,mBAAmB,cACnB,MAAM,GACJ,QAAQ,GAAC,UAAU,GAAC,aAAa,GAAC,KAAK,GAAC,MAAM,GAAC,cAAc,CAqBzE;IA6CD;;;;;;;;OAQG;IACH,SAFa,IAAI,CAOhB;IAED;;;;OAIG;IACH,WAFa,IAAI,CAUhB;IAED;;;;OAIG;IACH,qBAFa,MAAM,CAkBlB;IAID;;;;;;;;;OASG;IACH,aANW,WAAW,UACX;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAChF,UAAgB,EAAE,MAAM,CAAA;KAAC,iBACf,MAAM,GACJ,IAAI,CA6HhB;IAyGD;;;;;;OAMG;IACH,yBAHW,MAAM,GACJ,OAAO,CAgBnB;IAED;;;;;;OAMG;IACH,oBAHW,MAAM,GACJ,OAAO,CAoCnB;;CAgYJ;kCA/3CY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ;qCAC7C,OAAO,6BAA6B,EAAE,sBAAsB;qCALpC,2BAA2B;gCANhC,gDAAgD;gCAKhD,sBAAsB"}
+{"version":3,"file":"VGeoResidency.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoResidency.js"],"names":[],"mappings":"AA6GA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH;IAiKI;;;;;;;OAOG;IACH;QAN2C,IAAI,EAApC,sBAAsB;QACS,OAAO,GAAtC,oBAAoB;QACM,IAAI,GAA9B,eAAe;QACW,OAAO,GAAjC,eAAe;OA8BzB;IAID;;OAEG;IACH,oCAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,oBAEC;IAED;;;;OAIG;IACH,gCAGC;IAED,+BAEC;IAED,iCAEC;IAED,6BAEC;IAED,2BAEC;IAED,iCAEC;IAED,gCAEC;IAED;;;;OAIG;IACH,oCAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;OAGG;IACH,iCAEC;IAED,gCAEC;IAED,+BAEC;IAED,8BAEC;IAED;;OAEG;IACH,qCAQC;IAID;;;;;;;;;;OAUG;IACH,iBAHW,mBAAmB,GACjB,MAAM,CA8ClB;IAED;;;;;;OAMG;IACH,mBAHW,mBAAmB,GACjB,OAAO,CAgBnB;IAED;;;OAGG;IACH,sBAHW,mBAAmB,GACjB,OAAO,CAInB;IAED;;;;;;OAMG;IACH,cAJW,mBAAmB,cACnB,MAAM,GACJ,QAAQ,GAAC,UAAU,GAAC,aAAa,GAAC,KAAK,GAAC,MAAM,GAAC,cAAc,CAqBzE;IA6CD;;;;;;;;OAQG;IACH,SAFa,IAAI,CAOhB;IAED;;;;OAIG;IACH,WAFa,IAAI,CAUhB;IAED;;;;OAIG;IACH,qBAFa,MAAM,CAkBlB;IAID;;;;;;;;;OASG;IACH,aANW,WAAW,UACX;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAChF,UAAgB,EAAE,MAAM,CAAA;KAAC,iBACf,MAAM,GACJ,IAAI,CA6HhB;IAyGD;;;;;;OAMG;IACH,yBAHW,MAAM,GACJ,OAAO,CAgBnB;IAED;;;;;;OAMG;IACH,oBAHW,MAAM,GACJ,OAAO,CAoCnB;;CAgYJ;kCA/3CY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ;qCAC7C,OAAO,6BAA6B,EAAE,sBAAsB;qCANpC,2BAA2B;gCANhC,gDAAgD;gCAKhD,sBAAsB"}

package/src/shade/renderer/geometry/virtual/runtime/VGeoResidency.js

@@ -6,6 +6,7 @@ import { VGEO_PAGE_ROW_OFFSET } from "./layout/VGEO_PAGE_ROW_OFFSET.js";
 import { VGEO_WANT_WORDS } from "./layout/VGEO_WANT_WORDS.js";
 import { VGeoPageFetcher } from "./VGeoPageFetcher.js";
 import { VGeoResidencyOptions } from "./VGeoResidencyOptions.js";
+import { ctz32 } from "../../../../../core/binary/ctz32.js";
 
 /**
  * @typedef {import("../format/read/VGeoContainerReader.js").VGeoContainerReader} VGeoContainerReader
@@ -889,7 +890,7 @@ export class VGeoResidency {
             let bits = words[layout.touch_bits_base + word];
 
             while (bits !== 0) {
-                const bit = 31 - Math.clz32(bits & -bits);
+                const bit = ctz32(bits);
 
                 bits &= bits - 1;
 

package/src/shade/renderer/geometry/virtual/runtime/VirtualGeometry.d.ts

@@ -36,7 +36,22 @@ export class VirtualGeometry extends MeshletGeometry {
      * @type {number}
      */
     vg_row: number;
+    /**
+     * An ordinary geometry standing in for this one where a plain mesh is needed: what its geometry cache is baked
+     * from and its cards are drawn from. A cut of the container ({@link vgeo_to_proxy_mesh}) at
+     * {@link vgeo_proxy_triangle_limit} of the source's triangles, in the geometry's own space, with its attributes;
+     * asked for once, and the same proxy every time after.
+     *
+     * TODO: a container is expected to be delivered with its proxy, baked offline, and the proxy loaded here. Until
+     *   then it is cut here, through a reader of its own over the container's bytes: the shared {@link reader}'s pages
+     *   are its residency's, and the cut would install pages behind that residency's budget.
+     *
+     * @returns {Promise<MeshletGeometry>}
+     */
+    get_proxy(): Promise<MeshletGeometry>;
     isVirtualGeometry: boolean;
+    #private;
 }
 import { MeshletGeometry } from "../../MeshletGeometry.js";
+import { VGeoContainerReader } from "../format/read/VGeoContainerReader.js";
 //# sourceMappingURL=VirtualGeometry.d.ts.map

package/src/shade/renderer/geometry/virtual/runtime/VirtualGeometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VirtualGeometry.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VirtualGeometry.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAeI;;OAEG;IACH,yCAqBC;IAtCD;;;;OAIG;IACH,4BAAO;IAEP;;;;OAIG;IACH,QAFU,MAAM,CAEgB;IAyDpC,2BAA2C;CAF1C;gCA5F+B,0BAA0B"}
+{"version":3,"file":"VirtualGeometry.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VirtualGeometry.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAqBI;;OAEG;IACH,oBAFW,mBAAmB,EAuB7B;IA5CD;;;;OAIG;IACH,QAFU,mBAAmB,CAEtB;IAEP;;;;OAIG;IACH,QAFU,MAAM,CAEgB;IAkChC;;;;;;;;;;;OAWG;IACH,aAFa,QAAQ,eAAe,CAAC,CAQpC;IAwCL,2BAA2C;;CAF1C;gCAlI+B,0BAA0B;oCACtB,uCAAuC"}

package/src/shade/renderer/geometry/virtual/runtime/VirtualGeometry.js

@@ -1,5 +1,8 @@
 import { assert } from "../../../../../core/assert.js";
 import { MeshletGeometry } from "../../MeshletGeometry.js";
+import { VGeoContainerReader } from "../format/read/VGeoContainerReader.js";
+import { vgeo_proxy_triangle_limit } from "../proxy/vgeo_proxy_triangle_limit.js";
+import { vgeo_to_proxy_mesh } from "../proxy/vgeo_to_proxy_mesh.js";
 import { VGEO_GEOMETRY_ROW_NONE } from "./layout/VGEO_GEOMETRY_ROW_NONE.js";
 
 /**
@@ -38,6 +41,12 @@ export class VirtualGeometry extends MeshletGeometry {
      */
     vg_row = VGEO_GEOMETRY_ROW_NONE;
 
+    /**
+     * The proxy, once asked for.
+     * @type {Promise<MeshletGeometry>|null}
+     */
+    #proxy = null;
+
     /**
      * @param {VGeoContainerReader} reader an open container
      */
@@ -64,6 +73,35 @@ export class VirtualGeometry extends MeshletGeometry {
         this.primitive_count = Number(header.source_face_count);
     }
 
+    /**
+     * An ordinary geometry standing in for this one where a plain mesh is needed: what its geometry cache is baked
+     * from and its cards are drawn from. A cut of the container ({@link vgeo_to_proxy_mesh}) at
+     * {@link vgeo_proxy_triangle_limit} of the source's triangles, in the geometry's own space, with its attributes;
+     * asked for once, and the same proxy every time after.
+     *
+     * TODO: a container is expected to be delivered with its proxy, baked offline, and the proxy loaded here. Until
+     *   then it is cut here, through a reader of its own over the container's bytes: the shared {@link reader}'s pages
+     *   are its residency's, and the cut would install pages behind that residency's budget.
+     *
+     * @returns {Promise<MeshletGeometry>}
+     */
+    get_proxy() {
+        if (this.#proxy === null) {
+            this.#proxy = this.#cut_proxy();
+        }
+
+        return this.#proxy;
+    }
+
+    /**
+     * @returns {Promise<MeshletGeometry>}
+     */
+    async #cut_proxy() {
+        const reader = await VGeoContainerReader.open(this.reader.source);
+
+        return vgeo_to_proxy_mesh(reader, vgeo_proxy_triangle_limit(this.primitive_count));
+    }
+
     /**
      * A virtual geometry's identity is its **container**, not its meshlets.
      *

package/src/shade/renderer/geometry/virtual/sdf/VGeoSDFProxies.d.ts

@@ -1,91 +1,60 @@
 /**
- * The geometry caches of virtual geometry (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8, as S8 built it): a
- * {@link MeshSDFSource} of {@link GPUGeometrySDFManager}, which bakes a geometry's field from its tree, and a virtual
- * geometry has none. Each virtual geometry whose cache is asked for gets a proxy, the triangles of a cut of it, baked by
- * the mesh path as any geometry is, and its resident cache adopted into the geometry. Its instances are then composed
- * from it as a mesh's are.
+ * The geometry caches and cards of virtual geometry (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8, §17).
+ * {@link GPUGeometrySDFManager} bakes a geometry's field from its tree and captures its cards through its meshlets, and
+ * a virtual geometry has neither.
  *
- * **The cut.** A geometry is cut whole by the camera cut's own descent (`shader_vgeo_sdf_traverse`), at an error under
- * half its cache's level-0 voxel, in its own space, under a feedback slot of the extraction's own: a cluster's page not
- * resident is wanted there, as a view's are, and since a want lasts one reading the job is cut again each frame until
- * its cut stands nothing in. Its counters are read back each frame.
+ * Each virtual geometry whose cache is asked for gets its proxy ({@link VirtualGeometry#get_proxy}): an ordinary
+ * geometry in the same local space, with its attributes. The proxy is added to the geometry manager and the virtual
+ * geometry aliased to it ({@link GPUGeometrySDFManager#alias}). From there the proxy is any geometry: the virtual
+ * geometry's holders hold its cache, baked from its tree, and the virtual geometry's card sets capture its layout,
+ * drawn through its meshlets with the virtual geometry's own materials.
  *
- * **The mesh.** The frame after a cut that stood nothing in, the job's clusters are written out too, its vertices as
- * stored and its triangles as indices into them (`shader_vgeo_sdf_decode`), in room the last cut's counts made, and
- * read back with that frame's counters. A frame that cut it otherwise (a page evicted since, the cut grown) is not
- * taken, and the job is cut again.
+ * **The proxy's detail is its own**, not the cache's voxel's: a proxy coarser than the voxel bakes a coarser field and
+ * coarser cards than the asset would. A known discrepancy, kept: a hit on virtual geometry has a material at all.
  *
- * **The proxy.** One a frame, on the host: an ordinary geometry built from the mesh
- * (`meshlet_geometry_build_from_geometry`, which costs 2.2 to 4.1 µs a triangle, measured), added to the geometry
- * manager, its cache held with the side the geometry's holders draw. When its bake turns resident the next update gives
- * it to the geometry ({@link GPUGeometrySDFManager#adopt}) and removes the proxy.
- *
- * A geometry no longer asked for when its turn comes is let go, and one whose holders ask again is extracted again.
- * Settings that change the caches' voxel restart every job.
+ * A proxy is applied as it arrives, which is between frames: adding a geometry grows the geometry manager's buffers,
+ * which a frame's passes must not find replaced under them. A virtual geometry the geometry manager lets go takes its
+ * proxy with it; one let go before its proxy arrives has none applied. A proxy that cannot be had leaves its geometry
+ * waiting, black.
  */
 export class VGeoSDFProxies {
     /**
      * @param {Object} options
-     * @param {GPUDevice} options.device
-     * @param {GPUVirtualGeometryRuntime} options.runtime whose geometries' caches this makes
      * @param {GPUGeometryManager} options.geometries the scene's, whose caches the virtual geometries' are
-     * @param {number} [options.job_capacity] geometries extracted at once
      */
-    constructor({ device, runtime, geometries, job_capacity }: {
-        device: GPUDevice;
-        runtime: GPUVirtualGeometryRuntime;
+    constructor({ geometries }: {
         geometries: GPUGeometryManager;
-        job_capacity?: number;
     });
     /**
-     * The extraction's cut, whose `stats` say what the last reading of its slot counted.
-     * @returns {VGeoViewCut}
-     */
-    get cut(): VGeoViewCut;
-    /**
-     * Geometries being extracted.
-     * @returns {number}
-     */
-    get job_count(): number;
-    /**
-     * Geometries asked for that wait for a job, those let go since included.
+     * Virtual geometries whose proxy is asked for and has not arrived.
      * @returns {number}
      */
-    get requested_count(): number;
+    get pending_count(): number;
     /**
-     * Proxies built so far.
+     * Virtual geometries standing in through their proxy.
      * @returns {number}
      */
-    get extracted_count(): number;
+    get applied_count(): number;
     /**
-     * Caches given to their geometries so far.
+     * Proxies that could not be had.
      * @returns {number}
      */
-    get adopted_count(): number;
+    get failed_count(): number;
     /**
-     * Triangles of the proxies built so far.
-     * @returns {number}
-     */
-    get triangles_extracted(): number;
-    /**
-     * Entries the cluster list holds.
-     * @returns {number}
+     * The proxy a virtual geometry stands in through, once applied.
+     *
+     * @param {GPUGeometryMetadata} record the virtual geometry's
+     * @returns {MeshletGeometry|undefined}
      */
-    get cluster_capacity(): number;
+    proxy_of(record: GPUGeometryMetadata): MeshletGeometry | undefined;
     /**
-     * The frame's work, ahead of the caches' bake: the caches baked given to their geometries, a proxy built, jobs
-     * started, and the jobs' cut recorded into `graph` while the runtime's frame is open.
-     *
-     * @param {FrameGraph} graph
+     * Hear no more of the caches. The proxies applied stay with the geometry manager, as stand-ins their geometries
+     * are aliased to: removing one under its alias would leave its geometry's holders holding a geometry let go.
      */
-    graph_update(graph: FrameGraph): void;
     destroy(): void;
     #private;
 }
-export type FrameGraph = import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
 export type GPUGeometryManager = import("../../GPUGeometryManager.js").GPUGeometryManager;
 export type GPUGeometryMetadata = import("../../GPUGeometryMetadata.js").GPUGeometryMetadata;
 export type MeshletGeometry = import("../../MeshletGeometry.js").MeshletGeometry;
-export type GPUVirtualGeometryRuntime = import("../runtime/GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime;
-import { VGeoViewCut } from "../runtime/VGeoViewCut.js";
 //# sourceMappingURL=VGeoSDFProxies.d.ts.map

package/src/shade/renderer/geometry/virtual/sdf/VGeoSDFProxies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGeoSDFProxies.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/sdf/VGeoSDFProxies.js"],"names":[],"mappings":"AAiJA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAmEI;;;;;;OAMG;IACH;QAL8B,MAAM;QACU,OAAO,EAA1C,yBAAyB;QACG,UAAU,EAAtC,kBAAkB;QACD,YAAY,GAA7B,MAAM;OA8ChB;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAUC;IAED;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,+BAEC;IAsBD;;;;;OAKG;IACH,oBAFW,UAAU,QAsBpB;IA+dD,gBAqBC;;CACJ;yBAj2BY,OAAO,iEAAiE,EAAE,UAAU;iCACpF,OAAO,6BAA6B,EAAE,kBAAkB;kCACxD,OAAO,8BAA8B,EAAE,mBAAmB;8BAC1D,OAAO,0BAA0B,EAAE,eAAe;wCAClD,OAAO,yCAAyC,EAAE,yBAAyB;4BAjB5D,2BAA2B"}
+{"version":3,"file":"VGeoSDFProxies.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/sdf/VGeoSDFProxies.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAwBI;;;OAGG;IACH;QAFuC,UAAU,EAAtC,kBAAkB;OAU5B;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;;OAKG;IACH,iBAHW,mBAAmB,GACjB,eAAe,GAAC,SAAS,CAMrC;IAgED;;;OAGG;IACH,gBAcC;;CACJ;iCAjMY,OAAO,6BAA6B,EAAE,kBAAkB;kCACxD,OAAO,8BAA8B,EAAE,mBAAmB;8BAC1D,OAAO,0BAA0B,EAAE,eAAe"}