@woosh/meep-engine 3.60.4 → 3.60.6

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

@@ -0,0 +1,17 @@
+/**
+ * One cluster's meshlet metadata row, written at `buffer`'s position.
+ *
+ * `VGEO_FORMAT.md` §8: the 40-byte rows are synthesized from the cluster record — `aabb` becomes
+ * `bounds_box`, the u8 counts widen to u32, `encoding_flags` passes through. Only `address` depends
+ * on where the payload went, so the caller says.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {VGeoPage} page
+ * @param {number} cluster index within `page`
+ * @param {number} address where the cluster's payload starts in the data the row will be read against, in 4-byte words
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_meshlet_metadata_write(buffer: BinaryBuffer, page: VGeoPage, cluster: number, address: number): void;
+//# sourceMappingURL=vgeo_meshlet_metadata_write.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_meshlet_metadata_write.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_meshlet_metadata_write.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,2FANW,MAAM,WACN,MAAM,QAahB"}

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

@@ -0,0 +1,29 @@
+import { write_wgsl_type_value } from "../../../shader/type/serde/write_gpu_typed_buffer.js";
+import {
+    MESHLET_METADATA_STRUCT
+} from "../../meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+
+/**
+ * One cluster's meshlet metadata row, written at `buffer`'s position.
+ *
+ * `VGEO_FORMAT.md` §8: the 40-byte rows are synthesized from the cluster record — `aabb` becomes
+ * `bounds_box`, the u8 counts widen to u32, `encoding_flags` passes through. Only `address` depends
+ * on where the payload went, so the caller says.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {VGeoPage} page
+ * @param {number} cluster index within `page`
+ * @param {number} address where the cluster's payload starts in the data the row will be read against, in 4-byte words
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_meshlet_metadata_write(buffer, page, cluster, address) {
+    write_wgsl_type_value({
+        bounds_box: page.aabb.subarray(cluster * 6, cluster * 6 + 6),
+        address,
+        primitive_count: page.triangle_count[cluster],
+        vertex_count: page.vertex_count[cluster],
+        flags: page.encoding_flags[cluster],
+    }, buffer, MESHLET_METADATA_STRUCT);
+}

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

@@ -1 +1 @@
-{"version":3,"file":"vgeo_runtime_meshlet_batch.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_meshlet_batch.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4DALa,YAAY,CA6CxB;6BA9D4B,+BAA+B"}
+{"version":3,"file":"vgeo_runtime_meshlet_batch.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_meshlet_batch.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4DALa,YAAY,CAuCxB;6BAzD4B,+BAA+B"}

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

@@ -1,11 +1,11 @@
 import { assert } from "../../../../../core/assert.js";
 import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
 import { platform_compute_endianness } from "../../../../../core/binary/platform_compute_endianness.js";
-import { write_wgsl_type_value } from "../../../shader/type/serde/write_gpu_typed_buffer.js";
 import {
     MESHLET_METADATA_STRUCT
 } from "../../meshlet/encoding/MESHLET_METADATA_STRUCT.js";
 import { MeshletBatch } from "../../meshlet/MeshletBatch.js";
+import { vgeo_meshlet_metadata_write } from "./vgeo_meshlet_metadata_write.js";
 
 /**
  * A decoded page, as the meshlet pool takes it.
@@ -46,18 +46,12 @@ export function vgeo_runtime_meshlet_batch(page) {
     metadata.setCapacity(count * MESHLET_METADATA_STRUCT.size);
 
     for (let cluster = 0; cluster < count; cluster++) {
-        write_wgsl_type_value({
-            bounds_box: page.aabb.subarray(cluster * 6, cluster * 6 + 6),
-            /*
-             Words, and relative to the page's payload section — `GPUMeshletManager` adds the
-             allocation's own offset when it uploads. Format §11.8 makes every payload offset a
-             multiple of four, so this division is exact rather than rounded.
-             */
-            address: page.cluster_payload_offset[cluster] >>> 2,
-            primitive_count: page.triangle_count[cluster],
-            vertex_count: page.vertex_count[cluster],
-            flags: page.encoding_flags[cluster],
-        }, metadata, MESHLET_METADATA_STRUCT);
+        /*
+         Words, and relative to the page's payload section — `GPUMeshletManager` adds the
+         allocation's own offset when it uploads. Format §11.8 makes every payload offset a
+         multiple of four, so this division is exact rather than rounded.
+         */
+        vgeo_meshlet_metadata_write(metadata, page, cluster, page.cluster_payload_offset[cluster] >>> 2);
     }
 
     // `BinaryBuffer.data` is the ArrayBuffer itself, and `setCapacity` may have rounded it up;

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