@woosh/meep-engine 3.26.0 → 3.28.0

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

@@ -0,0 +1,100 @@
+/**
+ * @typedef {import("./GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime} GPUVirtualGeometryRuntime
+ */
+/**
+ * What cutting is per **view** rather than per frame.
+ *
+ * A view owns this the way it owns its HZB and its previous camera, and for the same reason: these
+ * are the things two views must not share. The runtime above it owns what a *scene* has — the page
+ * tables, the arena, the pool — and a frame owns the feedback buffer every view writes into.
+ *
+ * ## Why the params are here and not on the runtime
+ *
+ * `projection_k` is `screen_height / (2·tan(fov_y/2))`: a property of a render target and a camera,
+ * which is to say of a view. One buffer on the runtime meant one value for the frame, written from
+ * whichever view opened it — so a shadow cascade cut against the main view's projection and
+ * selected a level for a screen it is not drawn to. That is a live defect independent of anything
+ * a kept cut needs, and the fix is that each view writes its own.
+ *
+ * **One buffer per view, not one buffer with an offset per view.** Views are few — a main view and
+ * a handful of cascades — and a uniform is tens of bytes, so the saving from packing them would be
+ * nothing against giving every per-view value a second index to be wrong in.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VGeoViewCut {
+    /**
+     * @param {Object} options
+     * @param {GPUDevice} options.device
+     * @param {string} [options.label] names the buffer in a capture
+     */
+    constructor({ device, label }: {
+        device: GPUDevice;
+        label?: string;
+    });
+    /**
+     * The uniform every pass of this view's cut reads.
+     *
+     * @returns {GPUBuffer}
+     */
+    get params_buffer(): GPUBuffer;
+    /**
+     * @returns {number}
+     */
+    get projection_k(): number;
+    /**
+     * Where this view's last cut stood, as one bit per page row.
+     *
+     * @returns {GPUBuffer|undefined}
+     */
+    get frontier_buffer(): any;
+    /**
+     * @returns {number}
+     */
+    get frontier_word_count(): number;
+    /**
+     * Size the frontier to the tier it will name rows of.
+     *
+     * Lazily, and re-made rather than grown when the tier's capacity changes: what it holds
+     * is row indices of that tier, so a bigger tier does not extend the old answer, it
+     * invalidates it. Dropping it costs one frame of root descent, which is the fallback
+     * every other invalidation takes too.
+     *
+     * @param {number} page_row_capacity
+     * @returns {void}
+     */
+    resize_frontier(page_row_capacity: number): void;
+    /**
+     * Take this view's projection from the target it draws to and the camera it draws with.
+     *
+     * @param {Object} options
+     * @param {number} options.screen_height pixels of the render target
+     * @param {number} options.fov_y radians
+     * @returns {void}
+     */
+    set_projection({ screen_height, fov_y }: {
+        screen_height: number;
+        fov_y: number;
+    }): void;
+    /**
+     * Publish the frame's shared settings and this view's own, as one uniform.
+     *
+     * Everything but `projection_k` and `flags` is a property of the runtime or the frame, so it is
+     * read from the runtime at write time rather than mirrored here — a second copy of `tau` is a
+     * second thing to forget to update.
+     *
+     * @param {Object} options
+     * @param {GPUVirtualGeometryRuntime} options.runtime inside an open frame
+     * @param {boolean} [options.coarsen] whether this view's cut may walk up
+     * @returns {void}
+     */
+    write_params({ runtime, coarsen }: {
+        runtime: GPUVirtualGeometryRuntime;
+        coarsen?: boolean;
+    }): void;
+    destroy(): void;
+    #private;
+}
+export type GPUVirtualGeometryRuntime = import("./GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime;
+//# sourceMappingURL=VGeoViewCut.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VGeoViewCut.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoViewCut.js"],"names":[],"mappings":"AAOA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAwCI;;;;OAIG;IACH;QAH8B,MAAM;QACR,KAAK,GAAtB,MAAM;OAehB;IAED;;;;OAIG;IACH,+BAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAHW,MAAM,GACJ,IAAI,CAkBhB;IAED;;;;;;;OAOG;IACH;QAJ2B,aAAa,EAA7B,MAAM;QACU,KAAK,EAArB,MAAM;QACJ,IAAI,CAShB;IAED;;;;;;;;;;;OAWG;IACH;QAJ8C,OAAO,EAA1C,yBAAyB;QACP,OAAO,GAAzB,OAAO;QACL,IAAI,CA8BhB;IAED,gBAIC;;CACJ;wCAlNY,OAAO,gCAAgC,EAAE,yBAAyB"}

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

@@ -0,0 +1,219 @@
+import { assert } from "../../../../../core/assert.js";
+import { VGEO_CUT_FLAG_COARSEN } from "./cut/VGEO_CUT_FLAG_COARSEN.js";
+import { VGEO_CUT_FLAG_CULL } from "./cut/VGEO_CUT_FLAG_CULL.js";
+import { VGEO_CUT_PARAMS_STRUCT } from "./cut/VGEO_CUT_PARAMS_STRUCT.js";
+import { vgeo_frontier_words } from "./vgeo_frontier_words.js";
+import { write_gpu_typed_buffer } from "../../../shader/type/serde/write_gpu_typed_buffer.js";
+
+/**
+ * @typedef {import("./GPUVirtualGeometryRuntime.js").GPUVirtualGeometryRuntime} GPUVirtualGeometryRuntime
+ */
+
+/**
+ * What cutting is per **view** rather than per frame.
+ *
+ * A view owns this the way it owns its HZB and its previous camera, and for the same reason: these
+ * are the things two views must not share. The runtime above it owns what a *scene* has — the page
+ * tables, the arena, the pool — and a frame owns the feedback buffer every view writes into.
+ *
+ * ## Why the params are here and not on the runtime
+ *
+ * `projection_k` is `screen_height / (2·tan(fov_y/2))`: a property of a render target and a camera,
+ * which is to say of a view. One buffer on the runtime meant one value for the frame, written from
+ * whichever view opened it — so a shadow cascade cut against the main view's projection and
+ * selected a level for a screen it is not drawn to. That is a live defect independent of anything
+ * a kept cut needs, and the fix is that each view writes its own.
+ *
+ * **One buffer per view, not one buffer with an offset per view.** Views are few — a main view and
+ * a handful of cascades — and a uniform is tens of bytes, so the saving from packing them would be
+ * nothing against giving every per-view value a second index to be wrong in.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VGeoViewCut {
+    /**
+     * @type {GPUDevice}
+     */
+    #device;
+
+    /**
+     * @type {string}
+     */
+    #label;
+
+    /**
+     * @type {GPUBuffer}
+     */
+    #params;
+
+    /**
+     * Scratch for one params write, so a per-frame write allocates nothing.
+     * @type {ArrayBuffer}
+     */
+    #scratch;
+
+    /**
+     * `screen_height / (2 · tan(fov_y / 2))`, this view's.
+     * @type {number}
+     */
+    #projection_k = 1;
+
+    /**
+     * One bit per page row: the pages this view's cut drew from, kept between frames.
+     * Undefined until the first frame that knows how big the tier is.
+     * @type {GPUBuffer|undefined}
+     */
+    #frontier;
+
+    /**
+     * @type {number}
+     */
+    #frontier_word_count = 0;
+
+    /**
+     * @param {Object} options
+     * @param {GPUDevice} options.device
+     * @param {string} [options.label] names the buffer in a capture
+     */
+    constructor({ device, label = 'a view' }) {
+        assert.defined(device, 'device');
+
+        this.#device = device;
+        this.#label = label;
+
+        this.#params = device.createBuffer({
+            label: `VGeoViewCut/params (${label})`,
+            size: VGEO_CUT_PARAMS_STRUCT.aligned_size,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+
+        this.#scratch = new ArrayBuffer(VGEO_CUT_PARAMS_STRUCT.aligned_size);
+    }
+
+    /**
+     * The uniform every pass of this view's cut reads.
+     *
+     * @returns {GPUBuffer}
+     */
+    get params_buffer() {
+        return this.#params;
+    }
+
+    /**
+     * @returns {number}
+     */
+    get projection_k() {
+        return this.#projection_k;
+    }
+
+    /**
+     * Where this view's last cut stood, as one bit per page row.
+     *
+     * @returns {GPUBuffer|undefined}
+     */
+    get frontier_buffer() {
+        return this.#frontier;
+    }
+
+    /**
+     * @returns {number}
+     */
+    get frontier_word_count() {
+        return this.#frontier_word_count;
+    }
+
+    /**
+     * Size the frontier to the tier it will name rows of.
+     *
+     * Lazily, and re-made rather than grown when the tier's capacity changes: what it holds
+     * is row indices of that tier, so a bigger tier does not extend the old answer, it
+     * invalidates it. Dropping it costs one frame of root descent, which is the fallback
+     * every other invalidation takes too.
+     *
+     * @param {number} page_row_capacity
+     * @returns {void}
+     */
+    resize_frontier(page_row_capacity) {
+        const words = vgeo_frontier_words(page_row_capacity);
+
+        if (this.#frontier !== undefined && words === this.#frontier_word_count) {
+            return;
+        }
+
+        this.#frontier?.destroy();
+
+        this.#frontier_word_count = words;
+
+        this.#frontier = this.#device.createBuffer({
+            label: `VGeoViewCut/frontier (${this.#label})`,
+            size: Math.max(4, words * 4),
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        });
+    }
+
+    /**
+     * Take this view's projection from the target it draws to and the camera it draws with.
+     *
+     * @param {Object} options
+     * @param {number} options.screen_height pixels of the render target
+     * @param {number} options.fov_y radians
+     * @returns {void}
+     */
+    set_projection({ screen_height, fov_y }) {
+        assert.isNumber(screen_height, 'screen_height');
+        assert.greaterThan(screen_height, 0, 'screen_height');
+        assert.isNumber(fov_y, 'fov_y');
+        assert.greaterThan(fov_y, 0, 'fov_y');
+
+        this.#projection_k = screen_height / (2 * Math.tan(fov_y * 0.5));
+    }
+
+    /**
+     * Publish the frame's shared settings and this view's own, as one uniform.
+     *
+     * Everything but `projection_k` and `flags` is a property of the runtime or the frame, so it is
+     * read from the runtime at write time rather than mirrored here — a second copy of `tau` is a
+     * second thing to forget to update.
+     *
+     * @param {Object} options
+     * @param {GPUVirtualGeometryRuntime} options.runtime inside an open frame
+     * @param {boolean} [options.coarsen] whether this view's cut may walk up
+     * @returns {void}
+     */
+    write_params({ runtime, coarsen = false }) {
+        assert.defined(runtime, 'runtime');
+
+        const layout = runtime.feedback_layout;
+
+        assert.defined(layout, 'runtime.feedback_layout — begin_frame must have run');
+
+        write_gpu_typed_buffer({
+            tau: runtime.tau,
+            projection_k: this.#projection_k,
+            queue_capacity: runtime.queue_capacity,
+            claim_word_count: runtime.claim_word_capacity,
+            descent_steps: runtime.descent_steps,
+            page_slot_words: runtime.pool.page_slot_words,
+            touch_bits_base: layout.touch_bits_base,
+            want_base: layout.want_base,
+            want_capacity: runtime.want_capacity,
+            frontier_word_count: this.#frontier_word_count,
+            frame_tag: runtime.pool.frame,
+            instance_capacity: runtime.instance_capacity,
+            meshlet_capacity: runtime.meshlet_capacity,
+            flags: (runtime.cull_enabled ? VGEO_CUT_FLAG_CULL : 0)
+                | (coarsen ? VGEO_CUT_FLAG_COARSEN : 0),
+        }, VGEO_CUT_PARAMS_STRUCT, this.#scratch, 0);
+
+        this.#device.queue.writeBuffer(
+            this.#params, 0, this.#scratch, 0, VGEO_CUT_PARAMS_STRUCT.aligned_size
+        );
+    }
+
+    destroy() {
+        this.#params.destroy();
+
+        this.#frontier?.destroy();
+    }
+}

package/src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_EXPAND.d.ts

@@ -0,0 +1,17 @@
+/**
+ * What an executed cut item expands into — the three shapes a child can have.
+ *
+ * The traversal states its production as a *kind*, a count and a base rather than as children
+ * written anywhere, because any lane of the subgroup has to be able to build child `k` of any other
+ * lane's item out of a handful of shuffled words. A kind is what makes those words mean something
+ * without a second read of the row that produced them.
+ */
+export type VGEO_CUT_EXPAND = number;
+export namespace VGEO_CUT_EXPAND {
+    let NONE: number;
+    let NODES: number;
+    let CLUSTERS: number;
+    let PAGE: number;
+    let PARENTS: number;
+}
+//# sourceMappingURL=VGEO_CUT_EXPAND.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VGEO_CUT_EXPAND.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_EXPAND.js"],"names":[],"mappings":";;;;;;;;8BAYU,MAAM"}

package/src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_EXPAND.js

@@ -0,0 +1,47 @@
+/**
+ * What an executed cut item expands into — the three shapes a child can have.
+ *
+ * The traversal states its production as a *kind*, a count and a base rather than as children
+ * written anywhere, because any lane of the subgroup has to be able to build child `k` of any other
+ * lane's item out of a handful of shuffled words. A kind is what makes those words mean something
+ * without a second read of the row that produced them.
+ *
+ * @see shader_vgeo_cut_traverse
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @enum {number}
+ */
+export const VGEO_CUT_EXPAND = {
+    /**
+     * Nothing. Culled, below the cut, drawn, or clamped — every terminal case of the rule.
+     */
+    NONE: 0,
+    /**
+     * `count` child nodes of the same page, starting at node index `first`.
+     */
+    NODES: 1,
+    /**
+     * `count` clusters, spread over the `span` groups starting at group index `first`.
+     *
+     * The count is every cluster the leaf covers rather than a number of chunks: a lane no longer
+     * walks a run of them, so there is nothing to chunk. `span` is carried instead of assumed
+     * because the walk that maps child `k` back to a group has to terminate on a row the builder
+     * wrote, not on a bound this file believes about the format.
+     */
+    CLUSTERS: 2,
+    /**
+     * One node 0, in the page at `page_row` — a descent crossing a page boundary, already claimed
+     * by the lane that produced it.
+     */
+    PAGE: 3,
+    /**
+     * `count` entries of the parent rows of the page at `page_row`, starting at entry `first` —
+     * a group's whole parent list, which is one step of a walk up.
+     *
+     * Unlike {@link PAGE} these are **not** claimed by the producer; each child claims the page
+     * it resolves to when it is executed. See `VGEO_QUEUE_TARGET_PARENT_BIT` for why the claim
+     * cannot be hoisted into the producer the way the descent's can.
+     */
+    PARENTS: 4,
+};

package/src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_FLAG_COARSEN.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `VGEO_CUT_PARAMS_STRUCT.flags`: a cluster below the cut walks **up** instead of stopping.
+ *
+ * Every edge the descent follows points down, so a traversal that finds itself below the cut — its
+ * consuming step already projecting to no more than tau — can only stop, and a runtime that wanted
+ * to keep a cut between frames would have to answer every coarsening camera by re-descending from
+ * the root. With this set, such a cluster expands into the pages holding its group\x27s parents
+ * instead (format §6.3), and the walk continues until it reaches clusters the rule draws.
+ *
+ * Off by default, and the descent with it off is byte for byte the descent that shipped: the root
+ * seed reaches every group through a parent that projected above tau, so the branch this opens is
+ * one the descent does not take. It is a flag rather than a behaviour because the cut it belongs to
+ * is a *kept* one, which is per view, and CUT_PLAN_2026_09_14 §7.6 is where a view gets to say so.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {number}
+ */
+export const VGEO_CUT_FLAG_COARSEN: number;
+//# sourceMappingURL=VGEO_CUT_FLAG_COARSEN.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VGEO_CUT_FLAG_COARSEN.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_FLAG_COARSEN.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,oCAFU,MAAM,CAEuB"}

package/src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_FLAG_COARSEN.js

@@ -0,0 +1,19 @@
+/**
+ * `VGEO_CUT_PARAMS_STRUCT.flags`: a cluster below the cut walks **up** instead of stopping.
+ *
+ * Every edge the descent follows points down, so a traversal that finds itself below the cut — its
+ * consuming step already projecting to no more than tau — can only stop, and a runtime that wanted
+ * to keep a cut between frames would have to answer every coarsening camera by re-descending from
+ * the root. With this set, such a cluster expands into the pages holding its group\x27s parents
+ * instead (format §6.3), and the walk continues until it reaches clusters the rule draws.
+ *
+ * Off by default, and the descent with it off is byte for byte the descent that shipped: the root
+ * seed reaches every group through a parent that projected above tau, so the branch this opens is
+ * one the descent does not take. It is a flag rather than a behaviour because the cut it belongs to
+ * is a *kept* one, which is per view, and CUT_PLAN_2026_09_14 §7.6 is where a view gets to say so.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {number}
+ */
+export const VGEO_CUT_FLAG_COARSEN = 2;

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

@@ -1 +1 @@
-{"version":3,"file":"VGEO_CUT_PARAMS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_PARAMS_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,kDA+D2B;6BAjFE,yCAAyC"}
+{"version":3,"file":"VGEO_CUT_PARAMS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_PARAMS_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,kDAiF2B;6BAnGE,yCAAyC"}

package/src/shade/renderer/geometry/virtual/runtime/cut/VGEO_CUT_PARAMS_STRUCT.js

@@ -41,9 +41,25 @@ export const VGEO_CUT_PARAMS_STRUCT = WebGPUStruct.from({
      */
     claim_word_count: u32,
     /**
-     * How many clusters one group-chunk item covers.
+     * Words of this view's frontier bitmask — one bit per page row, and the bound a write
+     * into it is clamped against.
+     *
+     * Zero says this view keeps no frontier, which is what every cut did before one existed
+     * and what a cut still does when the flag is off: the bound rejects every write rather
+     * than a branch having to ask.
+     */
+    frontier_word_count: u32,
+    /**
+     * Steps of the descent one dispatch of the traversal runs before handing what it still holds
+     * back to the queue.
+     *
+     * WGSL will not let a loop around a subgroup operation have a non-uniform trip count, and
+     * nothing launders one — so the descent cannot stop when the wave runs dry. It runs this many
+     * times and masks, at about ten instructions a step for a wave with nothing left. That makes
+     * this a tuning knob between idle steps and dispatches, and not a safety bound:
+     * `VGEO_CUT_STAT.QUEUE_REMAINING` is what says it was set too low.
      */
-    cluster_chunk: u32,
+    descent_steps: u32,
     /**
      * Arena words one page slot holds — the stride a page row is multiplied by.
      *
@@ -53,19 +69,21 @@ export const VGEO_CUT_PARAMS_STRUCT = WebGPUStruct.from({
      */
     page_slot_words: u32,
     /**
-     * Word offset in the feedback buffer of the per-page-row touch stamps.
+     * Word offset in the feedback buffer of the touch bits — one per page row, set with an
+     * `atomicOr` when a page's claim is won. The bit is the dedup and the record at once, so there
+     * is no list to overflow and nothing per row to clear beyond the transient itself.
      */
-    touch_stamp_base: u32,
-    /**
-     * Word offset in the feedback buffer of the per-lookup-word want stamps. A want's stamp index
-     * is this plus the geometry's lookup offset plus the child page index, which is why the page
-     * lookup has its own buffer and its own allocator: it makes that a compact, dense index.
-     */
-    want_stamp_base: u32,
+    touch_bits_base: u32,
     want_base: u32,
     want_capacity: u32,
-    touch_base: u32,
-    touch_capacity: u32,
+    /**
+     * What this frame writes into the want-stamp buffer to claim a want, and what it compares
+     * against to dedup one. The stamps are persistent and one per lookup word — one per page of
+     * every registered geometry — so they are not cleared per frame; a stamp holding this frame's
+     * tag was written this frame, and any other value was not. Never zero, which is what a fresh
+     * buffer holds.
+     */
+    frame_tag: u32,
     /**
      * Records the VG instance buffer holds, for the one append in the cut that had no bound.
      */

package/src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_access.d.ts

@@ -1,14 +1,14 @@
 /**
- * Addressing and arithmetic shared by every pass of the cut — how to find a row, and how to project
- * an error.
+ * The arithmetic the cut rule is written in: where the camera is in an instance's own space, what
+ * an object-space error projects to in pixels, and whether a sphere is worth descending into at all.
  *
- * The arena is `array<u32>` with hand-written accessors rather than a marshalled struct array,
- * because it holds three different row types in one allocation per page and no struct array can say
- * that. The offsets it indexes with are the `layout/` constants, so the CPU writer and the kernel
- * are reading the same numbers rather than two copies of them.
+ * Addressing moved to {@link chunk_vgeo_cut_arena}, which this pulls in — a pass that only wants to
+ * find a row should not have to take the frustum test with it, and the passes that did not want to
+ * wrote their own accessor instead.
  *
- * Every buffer named here has to be declared by the importing shader. That is the price of sharing
- * addressing across passes, and it is the same bargain `chunk_scene_database_access` makes.
+ * Every buffer named here has to be declared by the importing shader — `instances`, plus whatever
+ * the arena chunk needs. That is the price of sharing addressing across passes, and it is the same
+ * bargain `chunk_scene_database_access` makes.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_vgeo_cut_access.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_access.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;GAeG;AACH,oCAFU,SAAS,CAqIZ;0BA/JmB,0CAA0C"}
+{"version":3,"file":"chunk_vgeo_cut_access.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_access.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,oCAFU,SAAS,CA+EQ;0BAjGD,0CAA0C"}

package/src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_access.js

@@ -1,26 +1,18 @@
 import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
-import { VGEO_CLUSTER_ROW_WORDS } from "../layout/VGEO_CLUSTER_ROW_WORDS.js";
-import { VGEO_GEOMETRY_ROW_WORDS } from "../layout/VGEO_GEOMETRY_ROW_WORDS.js";
-import { VGEO_GROUP_ROW_WORDS } from "../layout/VGEO_GROUP_ROW_WORDS.js";
 import { VGEO_INSTANCE_OFFSET } from "../layout/VGEO_INSTANCE_OFFSET.js";
-import { VGEO_INSTANCE_WORDS } from "../layout/VGEO_INSTANCE_WORDS.js";
-import { VGEO_NODE_ROW_LEAF_BIT } from "../layout/VGEO_NODE_ROW_LEAF_BIT.js";
-import { VGEO_NODE_ROW_OFFSET } from "../layout/VGEO_NODE_ROW_OFFSET.js";
-import { VGEO_NODE_ROW_WORDS } from "../layout/VGEO_NODE_ROW_WORDS.js";
-import { VGEO_PAGE_ROW_OFFSET } from "../layout/VGEO_PAGE_ROW_OFFSET.js";
-import { VGEO_PAGE_ROW_WORDS } from "../layout/VGEO_PAGE_ROW_WORDS.js";
+import { chunk_vgeo_cut_arena } from "./chunk_vgeo_cut_arena.js";
 
 /**
- * Addressing and arithmetic shared by every pass of the cut — how to find a row, and how to project
- * an error.
+ * The arithmetic the cut rule is written in: where the camera is in an instance's own space, what
+ * an object-space error projects to in pixels, and whether a sphere is worth descending into at all.
  *
- * The arena is `array<u32>` with hand-written accessors rather than a marshalled struct array,
- * because it holds three different row types in one allocation per page and no struct array can say
- * that. The offsets it indexes with are the `layout/` constants, so the CPU writer and the kernel
- * are reading the same numbers rather than two copies of them.
+ * Addressing moved to {@link chunk_vgeo_cut_arena}, which this pulls in — a pass that only wants to
+ * find a row should not have to take the frustum test with it, and the passes that did not want to
+ * wrote their own accessor instead.
  *
- * Every buffer named here has to be declared by the importing shader. That is the price of sharing
- * addressing across passes, and it is the same bargain `chunk_scene_database_access` makes.
+ * Every buffer named here has to be declared by the importing shader — `instances`, plus whatever
+ * the arena chunk needs. That is the price of sharing addressing across passes, and it is the same
+ * bargain `chunk_scene_database_access` makes.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -29,16 +21,6 @@ import { VGEO_PAGE_ROW_WORDS } from "../layout/VGEO_PAGE_ROW_WORDS.js";
 export const chunk_vgeo_cut_access = CodeChunk.from(
     //language=WGSL
     `
-const VG_PAGE_ROW_WORDS = ${VGEO_PAGE_ROW_WORDS}u;
-const VG_NODE_ROW_WORDS = ${VGEO_NODE_ROW_WORDS}u;
-const VG_GROUP_ROW_WORDS = ${VGEO_GROUP_ROW_WORDS}u;
-const VG_CLUSTER_ROW_WORDS = ${VGEO_CLUSTER_ROW_WORDS}u;
-const VG_INSTANCE_WORDS = ${VGEO_INSTANCE_WORDS}u;
-const VG_GEOMETRY_ROW_WORDS = ${VGEO_GEOMETRY_ROW_WORDS}u;
-
-const VG_NODE_LEAF_BIT = ${VGEO_NODE_ROW_LEAF_BIT}u;
-const VG_NODE_CHILD_COUNT_MASK = 0xffu;
-
 /**
  * Any error at or above this is the root's +infinity, however the file spelled it.
  *
@@ -49,50 +31,6 @@ const VG_NODE_CHILD_COUNT_MASK = 0xffu;
 const VG_ERROR_INFINITE = 3.0e38;
 const VG_PROJECTION_MAX = 3.4e38;
 
-/**
- * A page's slot: its header, then its node, group and cluster rows.
- *
- * The stride is a uniform rather than a constant because the tier derives it from the page size its
- * containers are bounded at, and it is a **multiply** rather than a table read because format
- * §11.14 made that legal — design §6 asked for fixed-size page slots from the start and the bound
- * is what it was waiting for. There is no page table, no allocator, and no second storage binding
- * to keep coherent with this one.
- */
-fn vg_slot_base(page_row: u32) -> u32 {
-    return page_row * params.page_slot_words;
-}
-
-fn vg_page_field(page_row: u32, field: u32) -> u32 {
-    return vg_arena[vg_slot_base(page_row) + field];
-}
-
-fn vg_node_base(page_row: u32) -> u32 {
-    return vg_slot_base(page_row) + VG_PAGE_ROW_WORDS;
-}
-
-fn vg_group_base(page_row: u32) -> u32 {
-    return vg_node_base(page_row)
-        + vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.NODE_COUNT}u) * VG_NODE_ROW_WORDS;
-}
-
-fn vg_cluster_base(page_row: u32) -> u32 {
-    return vg_group_base(page_row)
-        + vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.GROUP_COUNT}u) * VG_GROUP_ROW_WORDS;
-}
-
-fn vg_arena_f32(word: u32) -> f32 {
-    return bitcast<f32>(vg_arena[word]);
-}
-
-fn vg_sphere_at(word: u32) -> vec4<f32> {
-    return vec4<f32>(
-        bitcast<f32>(vg_arena[word]),
-        bitcast<f32>(vg_arena[word + 1u]),
-        bitcast<f32>(vg_arena[word + 2u]),
-        bitcast<f32>(vg_arena[word + 3u])
-    );
-}
-
 fn vg_instance_f32(instance_base: u32, field: u32) -> f32 {
     return bitcast<f32>(instances[instance_base + field]);
 }
@@ -108,7 +46,7 @@ fn vg_instance_eye(instance_base: u32) -> vec3<f32> {
 /**
  * \`err_px = r_e * screen_height / (2 * tan(fov_y / 2) * d)\`, with \`d\` the distance to the
  * **closest point** of the sphere — design §4, and written in that order so that it agrees with
- * \`select_cut.js\` term for term rather than merely in the limit.
+ * \`vgeo_select_cut\` term for term rather than merely in the limit.
  *
  * Two conventions carry real weight. A zero error projects to zero **unconditionally**, so a leaf
  * — whose error is exactly zero — does not become undrawable the moment the camera enters its
@@ -157,4 +95,4 @@ fn vg_sphere_outside_frustum(instance_base: u32, sphere: vec4<f32>) -> bool {
 
     return false;
 }
-`, []);
+`, [chunk_vgeo_cut_arena]);