@woosh/meep-engine 3.60.5 → 3.60.6

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