@woosh/meep-engine 3.24.0 → 3.25.0

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

@@ -0,0 +1,42 @@
+/**
+ * A `.vgeo` container, as the scene carries it.
+ *
+ * It is a {@link MeshletGeometry} on purpose rather than a parallel type: a `Mesh` binds one
+ * geometry to one material, the material buckets are keyed on the mesh, and design §7 is explicit
+ * that **VG carries geometry only** — a multi-material source splits into one geometry per material
+ * upstream of the builder. So a VG instance is an ordinary instance in every respect the scene
+ * cares about, and everything virtual about it lives behind `vg_row`.
+ *
+ * What it does not have is meshlets. `meshlets.count` is zero, which is not a placeholder: it is
+ * what makes `shader_meshes_to_meshlet_counts` contribute nothing for a VG instance without that
+ * shader knowing virtual geometry exists. Everything a VG instance draws comes from the cut
+ * selected for the view it is being drawn into.
+ *
+ * Bounds and the triangle count come from the container's header, where they describe the
+ * **normalized source mesh** — so an instance's world bounds are the asset's, not the cut's, which
+ * is what instance-level culling needs and what a cut must not be asked for before it is selected.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VirtualGeometry extends MeshletGeometry {
+    /**
+     * @param {VGeoContainerReader} reader an open container
+     */
+    constructor(reader: VGeoContainerReader);
+    /**
+     * The reader that owns the container's residency. One reader per asset, shared by every
+     * instance of it — design §6: instances of the same asset share pages and residency.
+     * @type {VGeoContainerReader}
+     */
+    reader: VGeoContainerReader;
+    /**
+     * Row in `GPUVirtualGeometryPool`'s geometry table, published into this geometry's
+     * `GEOMETRY_METADATA_STRUCT` row so a shader can find it from an instance.
+     * @type {number}
+     */
+    vg_row: number;
+    isVirtualGeometry: boolean;
+}
+import { MeshletGeometry } from "../../MeshletGeometry.js";
+//# sourceMappingURL=VirtualGeometry.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,96 @@
+import { assert } from "../../../../../core/assert.js";
+import { MeshletGeometry } from "../../MeshletGeometry.js";
+import { VGEO_GEOMETRY_ROW_NONE } from "./layout/VGEO_GEOMETRY_ROW_NONE.js";
+
+/**
+ * A `.vgeo` container, as the scene carries it.
+ *
+ * It is a {@link MeshletGeometry} on purpose rather than a parallel type: a `Mesh` binds one
+ * geometry to one material, the material buckets are keyed on the mesh, and design §7 is explicit
+ * that **VG carries geometry only** — a multi-material source splits into one geometry per material
+ * upstream of the builder. So a VG instance is an ordinary instance in every respect the scene
+ * cares about, and everything virtual about it lives behind `vg_row`.
+ *
+ * What it does not have is meshlets. `meshlets.count` is zero, which is not a placeholder: it is
+ * what makes `shader_meshes_to_meshlet_counts` contribute nothing for a VG instance without that
+ * shader knowing virtual geometry exists. Everything a VG instance draws comes from the cut
+ * selected for the view it is being drawn into.
+ *
+ * Bounds and the triangle count come from the container's header, where they describe the
+ * **normalized source mesh** — so an instance's world bounds are the asset's, not the cut's, which
+ * is what instance-level culling needs and what a cut must not be asked for before it is selected.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class VirtualGeometry extends MeshletGeometry {
+    /**
+     * The reader that owns the container's residency. One reader per asset, shared by every
+     * instance of it — design §6: instances of the same asset share pages and residency.
+     * @type {VGeoContainerReader}
+     */
+    reader;
+
+    /**
+     * Row in `GPUVirtualGeometryPool`'s geometry table, published into this geometry's
+     * `GEOMETRY_METADATA_STRUCT` row so a shader can find it from an instance.
+     * @type {number}
+     */
+    vg_row = VGEO_GEOMETRY_ROW_NONE;
+
+    /**
+     * @param {VGeoContainerReader} reader an open container
+     */
+    constructor(reader) {
+        super();
+
+        assert.defined(reader, 'reader');
+        assert.defined(reader.header, 'reader.header — the container must be open');
+
+        this.reader = reader;
+
+        const header = reader.header;
+
+        this.name = `vgeo:${header.total_pages} pages`;
+
+        this.bounding_box.set(header.object_bounds);
+        this.bounding_sphere.set(header.object_sphere);
+
+        /*
+         The source's triangle count, not the cut's. Nothing renders from it — it is what
+         `getIndexCount` reports and what a statistics panel shows — and reporting the cut's would
+         make a geometry's size a function of where the camera is standing.
+         */
+        this.primitive_count = Number(header.source_face_count);
+    }
+
+    /**
+     * A virtual geometry's identity is its **container**, not its meshlets.
+     *
+     * `MeshletGeometry` hashes and compares `this.meshlets`, and a virtual geometry's `MeshletBatch`
+     * is deliberately empty — so every virtual geometry in a scene hashed and compared equal to
+     * every other one, and `GPUGeometryManager.add` keys its content index on exactly that. The
+     * second `.vgeo` asset registered became another name for the first's record and drew the
+     * first's cut (REVIEW_LEDGER C6).
+     *
+     * Two instances over the *same* reader genuinely are one geometry — one geometry row, one page
+     * lookup, one cut — so sharing there is right, and that is what this says.
+     *
+     * @returns {number}
+     */
+    hash() {
+        // the low 32 bits of the asset id, which is xxh3-128 of the whole file — two containers
+        // agree here only if they are the same bytes
+        return Number(this.reader.header.asset_id_low64 & 0xFFFFFFFFn) >>> 0;
+    }
+
+    /**
+     * @param {MeshletGeometry} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return other?.isVirtualGeometry === true && other.reader === this.reader;
+    }
+}
+
+VirtualGeometry.prototype.isVirtualGeometry = true;

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

@@ -0,0 +1,16 @@
+/**
+ * `VGEO_CUT_PARAMS_STRUCT.flags`: run the frustum test at every node.
+ *
+ * Off is not merely "slower and identical" — a frustum cull can leave a genuine hole, because the
+ * parent that would have stood in over the culled region is not drawn either (it failed
+ * `project(self) <= tau`) and the child is never reached. Everything involved is inside the culled
+ * sphere, so the hole is in geometry the frustum rejected, but that makes it a real difference in
+ * the selected set rather than a performance knob. The agreement spec therefore holds the kernel
+ * against `vgeo_select_cut` with this **off**, which is also how `VGeoCutView` defaults.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {number}
+ */
+export const VGEO_CUT_FLAG_CULL: number;
+//# sourceMappingURL=VGEO_CUT_FLAG_CULL.d.ts.map

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

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

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

@@ -0,0 +1,15 @@
+/**
+ * `VGEO_CUT_PARAMS_STRUCT.flags`: run the frustum test at every node.
+ *
+ * Off is not merely "slower and identical" — a frustum cull can leave a genuine hole, because the
+ * parent that would have stood in over the culled region is not drawn either (it failed
+ * `project(self) <= tau`) and the child is never reached. Everything involved is inside the culled
+ * sphere, so the hole is in geometry the frustum rejected, but that makes it a real difference in
+ * the selected set rather than a performance knob. The agreement spec therefore holds the kernel
+ * against `vgeo_select_cut` with this **off**, which is also how `VGeoCutView` defaults.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {number}
+ */
+export const VGEO_CUT_FLAG_CULL = 1;

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

@@ -0,0 +1,19 @@
+/**
+ * What every pass of one cut needs to know about the buffers it was handed.
+ *
+ * A **uniform** rather than immediate data, deliberately. Immediates would fit — twelve words
+ * against a guaranteed 64-byte budget — but `maxImmediateSize` is an adapter limit that some
+ * contexts report as zero, and a cut that silently fails to build on a device is worse than one
+ * small uniform buffer the runtime writes once a frame.
+ *
+ * Every capacity here is a **host-side decision about a graph resource**, which is exactly why it
+ * travels rather than being a constant: the kernel bounds-checks every append against these, and a
+ * kernel that assumed a size would read past a pooled buffer the first time the pool handed back
+ * something smaller.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export const VGEO_CUT_PARAMS_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=VGEO_CUT_PARAMS_STRUCT.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,83 @@
+import { f32, u32 } from "../../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
+
+/**
+ * What every pass of one cut needs to know about the buffers it was handed.
+ *
+ * A **uniform** rather than immediate data, deliberately. Immediates would fit — twelve words
+ * against a guaranteed 64-byte budget — but `maxImmediateSize` is an adapter limit that some
+ * contexts report as zero, and a cut that silently fails to build on a device is worse than one
+ * small uniform buffer the runtime writes once a frame.
+ *
+ * Every capacity here is a **host-side decision about a graph resource**, which is exactly why it
+ * travels rather than being a constant: the kernel bounds-checks every append against these, and a
+ * kernel that assumed a size would read past a pooled buffer the first time the pool handed back
+ * something smaller.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export const VGEO_CUT_PARAMS_STRUCT = WebGPUStruct.from({
+    /**
+     * Pixels of permitted error — design §4's single quality/perf lever, defaulting to 1.
+     */
+    tau: f32,
+    /**
+     * `screen_height / (2 * tan(fov_y / 2))` — the projection's numerator, which is a property of
+     * the render target and the camera rather than of any instance.
+     *
+     * The collect pass multiplies it by each instance's own scale correction and stores the result
+     * per instance, so the traversal reads one number and never touches a transform.
+     */
+    projection_k: f32,
+    /**
+     * Items one queue holds. The wavefront clamps its own count to this, so an overflowing
+     * iteration loses work rather than dispatching over a buffer's end.
+     */
+    queue_capacity: u32,
+    /**
+     * Words in the claim bitmask. An instance whose slice does not fit is refused outright — see
+     * `VGEO_CUT_STAT.INSTANCES_DROPPED` for why that is the safe direction.
+     */
+    claim_word_count: u32,
+    /**
+     * How many clusters one group-chunk item covers.
+     */
+    cluster_chunk: u32,
+    /**
+     * Arena words one page slot holds — the stride a page row is multiplied by.
+     *
+     * A host-side decision, like every other capacity here: the tier derives it from the page size
+     * its containers are bounded at (`vgeo_runtime_page_slot_words`), and a kernel that baked it in
+     * would read another page's rows the first time a pool was built for a different page size.
+     */
+    page_slot_words: u32,
+    /**
+     * Word offset in the feedback buffer of the per-page-row touch stamps.
+     */
+    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,
+    want_base: u32,
+    want_capacity: u32,
+    touch_base: u32,
+    touch_capacity: u32,
+    /**
+     * Records the VG instance buffer holds, for the one append in the cut that had no bound.
+     */
+    instance_capacity: u32,
+    /**
+     * Records the shared meshlet collection holds — the collection this frame's expansion sites
+     * were actually handed, taken as the minimum across them, and **not** a frame-scoped constant.
+     * It was 1 << 20 against an engine default of 2e5.
+     */
+    meshlet_capacity: u32,
+    /**
+     * @see VGEO_CUT_FLAG_CULL
+     */
+    flags: u32,
+}, "VGeoCutParams").pack();

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

@@ -0,0 +1,9 @@
+/**
+ * Lanes per workgroup of the traversal kernel — one queue item each.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {number}
+ */
+export const VGEO_CUT_WORKGROUP_SIZE: number;
+//# sourceMappingURL=VGEO_CUT_WORKGROUP_SIZE.d.ts.map

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * Lanes per workgroup of the traversal kernel — one queue item each.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {number}
+ */
+export const VGEO_CUT_WORKGROUP_SIZE = 64;

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

@@ -0,0 +1,19 @@
+/**
+ * Addressing and arithmetic shared by every pass of the cut — how to find a row, and how to project
+ * an error.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {CodeChunk}
+ */
+export const chunk_vgeo_cut_access: CodeChunk;
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_vgeo_cut_access.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,160 @@
+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";
+
+/**
+ * Addressing and arithmetic shared by every pass of the cut — how to find a row, and how to project
+ * an error.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ * @type {CodeChunk}
+ */
+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.
+ *
+ * Tested rather than relied on: an infinity travels through \`error * k / d\` correctly on every
+ * conformant implementation, and a kernel whose root cluster stops refining on a device that
+ * flushes it is a failure nothing downstream could attribute.
+ */
+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]);
+}
+
+fn vg_instance_eye(instance_base: u32) -> vec3<f32> {
+    return vec3<f32>(
+        vg_instance_f32(instance_base, ${VGEO_INSTANCE_OFFSET.EYE}u),
+        vg_instance_f32(instance_base, ${VGEO_INSTANCE_OFFSET.EYE + 1}u),
+        vg_instance_f32(instance_base, ${VGEO_INSTANCE_OFFSET.EYE + 2}u)
+    );
+}
+
+/**
+ * \`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.
+ *
+ * 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
+ * sphere. And a camera inside the sphere projects to the maximum when the error is not zero, so the
+ * cluster refines; the two rules meet at the same \`if\` and disagreeing about which comes first is
+ * how a leaf disappears at point-blank range.
+ */
+fn vg_project(error: f32, sphere: vec4<f32>, eye: vec3<f32>, k: f32) -> f32 {
+    if (error == 0.0) {
+        return 0.0;
+    }
+
+    if (error >= VG_ERROR_INFINITE) {
+        return VG_PROJECTION_MAX;
+    }
+
+    let distance = length(eye - sphere.xyz) - sphere.w;
+
+    if (distance <= 0.0) {
+        return VG_PROJECTION_MAX;
+    }
+
+    return error * k / distance;
+}
+
+/**
+ * Whether a sphere is entirely outside the instance's object-space frustum.
+ *
+ * Five planes, not six. The projection is infinite reverse-Z, so the far plane's row is degenerate
+ * and normalizing it produces nothing a test can use; the instance record orders it last precisely
+ * so that "the first five" is true by construction.
+ */
+fn vg_sphere_outside_frustum(instance_base: u32, sphere: vec4<f32>) -> bool {
+    for (var plane = 0u; plane < 5u; plane = plane + 1u) {
+        let word = instance_base + ${VGEO_INSTANCE_OFFSET.FRUSTUM}u + plane * 4u;
+
+        let distance = bitcast<f32>(instances[word]) * sphere.x
+            + bitcast<f32>(instances[word + 1u]) * sphere.y
+            + bitcast<f32>(instances[word + 2u]) * sphere.z
+            + bitcast<f32>(instances[word + 3u]);
+
+        if (distance < -sphere.w) {
+            return true;
+        }
+    }
+
+    return false;
+}
+`, []);

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

@@ -0,0 +1,3 @@
+export const shader_vgeo_cut_collect: ComputeShader;
+import { ComputeShader } from "../../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_vgeo_cut_collect.d.ts.map

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

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