@woosh/meep-engine 3.59.0 → 3.60.0

package/src/view/elements/progress/segmented/segmented-resource-bar.css

@@ -0,0 +1,142 @@
+/*
+ Default styling for SegmentedResourceBarView.
+
+ Theming: every colour, notch height and the ghost go through a --segmented-bar-* custom property with a
+ fallback, so a game re-skins the bar by defining the properties on the bar or any ancestor, without overriding a
+ selector. Each notch carries its tier's class_name; the three classes below are the ones SEGMENT_TIERS_DEFAULT
+ uses, and a game's own tiers may reuse them or style their own.
+
+ Import this from a style entry point, never from a logic module. Give the bar its width and height there; keep
+ borders off the bar itself (use box-shadow or an outline), so the fill and the notches share one box.
+
+ The ghost's hold and ease are driven from script, which reads prefers-reduced-motion: under it the ghost holds,
+ then snaps.
+*/
+
+.ui-segmented-resource-bar-view {
+    position: relative;
+    overflow: hidden;
+    height: var(--segmented-bar-height, 12px);
+    background: var(--segmented-bar-background, rgba(0, 0, 0, 0.6));
+    box-shadow: var(--segmented-bar-frame, 0 0 0 1px rgba(0, 0, 0, 0.8));
+}
+
+.ui-segmented-resource-bar-view > .ghost {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    width: 0;
+    background: var(--segmented-bar-ghost-color, rgba(255, 236, 196, 0.85));
+}
+
+.ui-segmented-resource-bar-view > .fill-container,
+.ui-segmented-resource-bar-view > .notches,
+.ui-segmented-resource-bar-view > .cells {
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+}
+
+.ui-segmented-resource-bar-view > .notches,
+.ui-segmented-resource-bar-view > .highlights {
+    pointer-events: none;
+}
+
+.ui-segmented-resource-bar-view .fill {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    background: var(--segmented-bar-fill-color, #3fae4a);
+}
+
+/* the second and third stacked values, e.g. shield over health */
+.ui-segmented-resource-bar-view .fill.value-1 {
+    background: var(--segmented-bar-fill-1-color, #d8d8d8);
+}
+
+.ui-segmented-resource-bar-view .fill.value-2 {
+    background: var(--segmented-bar-fill-2-color, #7a5fd0);
+}
+
+/* notches */
+
+.ui-segmented-resource-bar-view .notch {
+    position: absolute;
+    top: 0;
+    height: var(--segmented-bar-tick-height, 100%);
+    background: var(--segmented-bar-tick-color, rgba(0, 0, 0, 0.6));
+    box-shadow: var(--segmented-bar-tick-highlight, none);
+}
+
+.ui-segmented-resource-bar-view .notch.segment-tier-minor {
+    height: var(--segmented-bar-tick-minor-height, 45%);
+    background: var(--segmented-bar-tick-minor-color, rgba(0, 0, 0, 0.4));
+}
+
+.ui-segmented-resource-bar-view .notch.segment-tier-major {
+    height: var(--segmented-bar-tick-major-height, 100%);
+    background: var(--segmented-bar-tick-major-color, rgba(0, 0, 0, 0.6));
+}
+
+.ui-segmented-resource-bar-view .notch.segment-tier-super {
+    height: var(--segmented-bar-tick-super-height, 100%);
+    background: var(--segmented-bar-tick-super-color, rgba(0, 0, 0, 0.85));
+}
+
+/* cells */
+
+.ui-segmented-resource-bar-view.mode-cells {
+    /* the gaps between cells show the bar through them */
+    background: var(--segmented-bar-cell-gap-color, transparent);
+    box-shadow: none;
+}
+
+.ui-segmented-resource-bar-view .cell {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    overflow: hidden;
+    background: var(--segmented-bar-cell-empty-color, rgba(0, 0, 0, 0.55));
+}
+
+.ui-segmented-resource-bar-view .cell-ghost,
+.ui-segmented-resource-bar-view .cell-fill {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    width: 0;
+}
+
+.ui-segmented-resource-bar-view .cell-ghost {
+    background: var(--segmented-bar-ghost-color, rgba(255, 236, 196, 0.85));
+}
+
+.ui-segmented-resource-bar-view .cell-fill {
+    background: var(--segmented-bar-cell-filled-color, #e8c25a);
+}
+
+/* a cell filling up one at a time, e.g. a round being loaded */
+.ui-segmented-resource-bar-view .cell.partial > .cell-fill {
+    background: var(--segmented-bar-cell-partial-color, rgba(232, 194, 90, 0.6));
+}
+
+/* highlights (the view's `highlights` list) */
+
+.ui-segmented-resource-bar-view > .highlights {
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+}
+
+.ui-segmented-resource-bar-view .highlight {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    background: var(--segmented-bar-highlight-color, rgba(255, 255, 255, 0.25));
+}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.d.ts

@@ -1,35 +0,0 @@
-/**
- * Words of the mesh provider's statistics, every one an atomic that accumulates.
- */
-export const MESH_BRICK_STATISTIC_INSTANCES_DROPPED: 0;
-export const MESH_BRICK_STATISTIC_CANDIDATES_DROPPED: 1;
-export const MESH_BRICK_STATISTIC_NODES_DROPPED: 2;
-export const MESH_BRICK_STATISTIC_WORDS: 4;
-/**
- * @type {WebGPUStruct}
- */
-export const MESH_BRICK_PROVIDER_SETTINGS: WebGPUStruct;
-/**
- * The mesh provider's pass (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7): a 64-lane workgroup a taken
- * cell, dispatched by take.
- *
- * **Gather.** A cooperative TLAS query with the cell grown by the cascade's band, every leaf filtered
- * by `mesh_brick_accept`: in the SDF world, resident, at least half a voxel across. Up to
- * {@link MESH_BRICK_INSTANCE_LIMIT} instances, a lane each, go into workgroup memory; past it they are
- * dropped and counted, as are candidates and subtrees the query itself dropped.
- *
- * **512 texels, eight a lane**, each `mesh_brick_texel`: the minimum over the instances of their
- * sampled distance, and its row. A lane merges its texels into its two staging words, which no other
- * thread touches (contract 1), as the byte minimum (contract 2).
- *
- * **Objects** (contract 3): per 2³-texel cell, the provider's row at its own nearest texel replaces the
- * staged object when the provider's cell minimum is below the staged one from before the merge; ties
- * keep the staged object. A cell's four lanes fold their texels in through workgroup atomics, and the
- * last of them decides, so that no lane waits on another.
- *
- * @type {ComputeShader}
- */
-export const shader_mesh_brick_provider: ComputeShader;
-import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
-import { ComputeShader } from "../../../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_mesh_brick_provider.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_mesh_brick_provider.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.js"],"names":[],"mappings":"AAiCA;;GAEG;AACH,uDAAwD;AACxD,wDAAyD;AACzD,mDAAoD;AACpD,2CAA4C;AAE5C;;GAEG;AACH,2CAFU,YAAY,CAOU;AAoKhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yCAFU,aAAa,CAMpB;6BA1N0B,yCAAyC;8BAJxC,qCAAqC"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.js

@@ -1,238 +0,0 @@
-import { assert } from "../../../../../../core/assert.js";
-import { WebGPUExtensionType } from "../../../../../descriptor/WebGPUExtensionType.js";
-import {
-    MESH_SDF_ATLAS_RESOURCE,
-    MESH_SDF_HEADERS_RESOURCE,
-    MESH_SDF_INDIRECTION_RESOURCE,
-    MESH_SDF_SAMPLER_RESOURCE
-} from "../../../../geometry/sdf/MESH_SDF_RESOURCES.js";
-import { BVH2_NODE_STRUCT } from "../../../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
-import { BVH_STRUCT } from "../../../../shader/chunk/bvh/BVH_STRUCT.js";
-import { chunk_bvh_query_aabb_cooperative } from "../../../../shader/chunk/bvh/chunk_bvh_query_aabb_cooperative.js";
-import { BVH_QUERY_AABB_WORKGROUP_SIZE } from "../../../../shader/chunk/bvh/chunk_bvh_query_aabb_frontier.js";
-import { CLIPMAP_LEVEL_ARRAY } from "../../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
-import { chunk_folded_workgroup_index } from "../../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
-import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { atomic_u32, u32 } from "../../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
-import { BRICK_CELL_WORKGROUP_SIZE, BRICK_OBJECT_CELLS_PER_AXIS } from "../BRICK_CLIPMAP.js";
-import { chunk_brick_object } from "../chunk_brick_object.js";
-import { chunk_brick_provider } from "../chunk_brick_provider.js";
-import {
-    BRICK_RING_RESOURCE,
-    BRICK_STAGING_RESOURCE,
-    BRICK_TAKE_RESOURCE,
-    chunk_brick_clipmap
-} from "../chunk_brick_clipmap.js";
-import { chunk_mesh_brick_instance } from "./chunk_mesh_brick_instance.js";
-import { chunk_mesh_brick_texel } from "./chunk_mesh_brick_texel.js";
-import { MESH_BRICK_INSTANCE_LIMIT, MESH_BRICK_INSTANCE_STRUCT } from "./MESH_BRICK_INSTANCE_STRUCT.js";
-
-/**
- * Words of the mesh provider's statistics, every one an atomic that accumulates.
- */
-export const MESH_BRICK_STATISTIC_INSTANCES_DROPPED = 0;
-export const MESH_BRICK_STATISTIC_CANDIDATES_DROPPED = 1;
-export const MESH_BRICK_STATISTIC_NODES_DROPPED = 2;
-export const MESH_BRICK_STATISTIC_WORDS = 4;
-
-/**
- * @type {WebGPUStruct}
- */
-export const MESH_BRICK_PROVIDER_SETTINGS = WebGPUStruct.from({
-    /** keys `brick_ring` holds, a power of two */
-    ring_capacity: u32,
-    /** cells a cascade's window has a side */
-    resolution: u32,
-}, "MeshBrickProviderSettings");
-
-// the gather is the whole workgroup's: a cell's workgroup is the query's
-assert.equal(BRICK_CELL_WORKGROUP_SIZE, BVH_QUERY_AABB_WORKGROUP_SIZE, 'a taken cell\'s workgroup runs the cooperative query');
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.setImmediate("settings", MESH_BRICK_PROVIDER_SETTINGS);
-
-resources.createGroup()
-    .add(BRICK_TAKE_RESOURCE)
-    .add(BRICK_RING_RESOURCE)
-    .add(BRICK_STAGING_RESOURCE)
-    .addUniform("brick_levels", CLIPMAP_LEVEL_ARRAY)
-    .addStorageBuffer("mesh_brick_statistics", WebGPUArray.from(atomic_u32), true);
-
-resources.createGroup()
-    .addStorageBuffer("tlas", BVH_STRUCT)
-    .addStorageBuffer("scene_database", WebGPUArray.from(u32))
-    .add(MESH_SDF_HEADERS_RESOURCE)
-    .add(MESH_SDF_INDIRECTION_RESOURCE)
-    .add(MESH_SDF_ATLAS_RESOURCE)
-    .add(MESH_SDF_SAMPLER_RESOURCE);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const MESH_BRICK_INSTANCE_LIMIT = ${MESH_BRICK_INSTANCE_LIMIT}u;
-
-/** the cascade's voxel, the same for the whole workgroup: what the gather's resolution cull weighs a box by */
-var<private> mesh_brick_voxel: f32;
-
-var<workgroup> instances: array<${MESH_BRICK_INSTANCE_STRUCT.wgsl_ref}, ${MESH_BRICK_INSTANCE_LIMIT}>;
-var<workgroup> cell_taken: u32;
-
-/** per object cell: its nearest texel's key, its staged minimum (as 255 less the byte), and its lanes done */
-var<workgroup> object_best: array<atomic<u32>, ${BRICK_OBJECT_CELLS_PER_AXIS ** 3}>;
-var<workgroup> object_staged: array<atomic<u32>, ${BRICK_OBJECT_CELLS_PER_AXIS ** 3}>;
-var<workgroup> object_lanes: array<atomic<u32>, ${BRICK_OBJECT_CELLS_PER_AXIS ** 3}>;
-
-fn bvh_query_aabb_node(index: u32) -> ${BVH2_NODE_STRUCT.wgsl_ref} {
-    return tlas.nodes[index];
-}
-
-fn bvh_query_aabb_accept_leaf(payload: u32, bounds: array<f32, 6>) -> bool {
-    return mesh_brick_accept(payload, bounds, mesh_brick_voxel);
-}
-
-fn mesh_brick_instance_at(i: u32) -> ${MESH_BRICK_INSTANCE_STRUCT.wgsl_ref} {
-    return instances[i];
-}
-
-@compute @workgroup_size(${BRICK_CELL_WORKGROUP_SIZE})
-fn main(
-    @builtin(workgroup_id) workgroup_id: vec3<u32>,
-    @builtin(local_invocation_index) lane: u32,
-) {
-    let build = folded_workgroup_index(workgroup_id);
-
-    if (lane == 0u) {
-        cell_taken = brick_take[BRICK_TAKE_COUNT];
-    }
-
-    // a folded dispatch's tail leaves whole
-    if (build >= workgroupUniformLoad(&cell_taken)) {
-        return;
-    }
-
-    let at = brick_provider_cell(brick_provider_key(build, settings.ring_capacity), settings.resolution);
-
-    let voxel = at.voxel;
-    let band = at.band;
-    let corner = at.corner;
-    let far = at.far;
-
-    mesh_brick_voxel = voxel;
-
-    // every instance whose box comes within the band of the cell
-    let gathered = bvh_query_aabb_cooperative(tlas.root, array<f32, 6>(corner.x - band, corner.y - band, corner.z - band, far.x + band, far.y + band, far.z + band), lane);
-    let count = min(gathered.candidate_count, MESH_BRICK_INSTANCE_LIMIT);
-
-    if (lane < count) {
-        instances[lane] = mesh_brick_instance(bvh_query_aabb_candidates[lane], voxel);
-    }
-
-    if (lane == 0u) {
-        if (gathered.candidate_count > count) {
-            atomicAdd(&mesh_brick_statistics[${MESH_BRICK_STATISTIC_INSTANCES_DROPPED}u], gathered.candidate_count - count);
-        }
-
-        if (gathered.candidates_dropped > 0u) {
-            atomicAdd(&mesh_brick_statistics[${MESH_BRICK_STATISTIC_CANDIDATES_DROPPED}u], gathered.candidates_dropped);
-        }
-
-        if (gathered.nodes_dropped > 0u) {
-            atomicAdd(&mesh_brick_statistics[${MESH_BRICK_STATISTIC_NODES_DROPPED}u], gathered.nodes_dropped);
-        }
-    }
-
-    workgroupBarrier();
-
-    // eight texels a lane, x fastest, at y = lane mod 8 and z = lane / 8: the staging's two words
-    let y = lane % 8u;
-    let z = lane / 8u;
-    let first = build * BRICK_STAGING_WORDS + 2u * lane;
-
-    var best = vec4<u32>(0u);
-    var staged_min = vec4<u32>(255u);
-
-    for (var w = 0u; w < 2u; w++) {
-        var word = brick_staging[first + w];
-
-        for (var b = 0u; b < 4u; b++) {
-            let x = 4u * w + b;
-            let shift = 8u * b;
-            let staged = (word >> shift) & 0xffu;
-
-            let texel = mesh_brick_texel(corner + vec3<f32>(f32(x), f32(y), f32(z)) * voxel, count);
-            let byte = brick_encode(texel.distance, band);
-
-            // contract 2: the encoding is monotone, so the minimum of the bytes is the byte of the minimum
-            word = (word & ~(0xffu << shift)) | (min(staged, byte) << shift);
-
-            // the object cell's two texels of this lane
-            let o = x / 2u;
-
-            staged_min[o] = min(staged_min[o], staged);
-            best[o] = max(best[o], brick_object_key(byte, texel.row));
-        }
-
-        brick_staging[first + w] = word;
-    }
-
-    // contract 3, per object cell: its four lanes each fold in their texels, and the last decides
-    for (var o = 0u; o < ${BRICK_OBJECT_CELLS_PER_AXIS}u; o++) {
-        let object = o + ${BRICK_OBJECT_CELLS_PER_AXIS}u * ((y / 2u) + ${BRICK_OBJECT_CELLS_PER_AXIS}u * (z / 2u));
-
-        atomicMax(&object_best[object], best[o]);
-        atomicMax(&object_staged[object], 255u - staged_min[o]);
-
-        if (atomicAdd(&object_lanes[object], 1u) != 3u) {
-            continue;
-        }
-
-        // the provider's cell minimum against the staged one from before its merge: ties keep the staged
-        let nearest = atomicLoad(&object_best[object]);
-
-        if (brick_object_key_byte(nearest) < 255u - atomicLoad(&object_staged[object])) {
-            brick_staging[build * BRICK_STAGING_WORDS + BRICK_STAGING_DISTANCE_WORDS + object] = brick_object_key_row(nearest);
-        }
-    }
-}
-`, [
-    chunk_brick_clipmap,
-    chunk_brick_provider,
-    chunk_folded_workgroup_index,
-    chunk_bvh_query_aabb_cooperative,
-    chunk_mesh_brick_instance,
-    chunk_mesh_brick_texel,
-    chunk_brick_object,
-]);
-
-body.addExtension(WebGPUExtensionType.Subgroups);
-
-/**
- * The mesh provider's pass (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7): a 64-lane workgroup a taken
- * cell, dispatched by take.
- *
- * **Gather.** A cooperative TLAS query with the cell grown by the cascade's band, every leaf filtered
- * by `mesh_brick_accept`: in the SDF world, resident, at least half a voxel across. Up to
- * {@link MESH_BRICK_INSTANCE_LIMIT} instances, a lane each, go into workgroup memory; past it they are
- * dropped and counted, as are candidates and subtrees the query itself dropped.
- *
- * **512 texels, eight a lane**, each `mesh_brick_texel`: the minimum over the instances of their
- * sampled distance, and its row. A lane merges its texels into its two staging words, which no other
- * thread touches (contract 1), as the byte minimum (contract 2).
- *
- * **Objects** (contract 3): per 2³-texel cell, the provider's row at its own nearest texel replaces the
- * staged object when the provider's cell minimum is below the staged one from before the merge; ties
- * keep the staged object. A cell's four lanes fold their texels in through workgroup atomics, and the
- * last of them decides, so that no lane waits on another.
- *
- * @type {ComputeShader}
- */
-export const shader_mesh_brick_provider = ComputeShader.from({
-    label: "Brick Clipmap Mesh Provider",
-    resources,
-    body,
-});

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/VGEO_BRICK.d.ts

@@ -1,99 +0,0 @@
-/**
- * The provider's settings, an immediate of each of its passes.
- * @type {WebGPUStruct}
- */
-export const VGEO_BRICK_SETTINGS: WebGPUStruct;
-/**
- * Where a pair record keeps the box it is cut against: the cell grown by the field's band, in the instance's
- * object space, lower xyz then upper xyz, in the words a view's record keeps its frustum in.
- * @type {number}
- */
-export const VGEO_BRICK_PAIR_BOX: number;
-/**
- * Where a pair record keeps its taken cell: the first word a view's record leaves free.
- * @type {number}
- */
-export const VGEO_BRICK_PAIR_BUILD: number;
-/**
- * Pair records a frame holds, for each cell of its take budget; past them, pairs are dropped and counted.
- * @type {number}
- */
-export const VGEO_BRICK_PAIRS_PER_CELL: number;
-/**
- * Clusters a taken cell's list holds; past them, clusters are dropped and counted.
- * @type {number}
- */
-export const VGEO_BRICK_CELL_CLUSTERS: number;
-/**
- * A waiting cell: its key, then what the first cluster of its cut that stood something in waits on, and what wants
- * it. The page it waits on is `PAGE` of the geometry whose page lookup starts at `LOOKUP`, and `GROUP` is the group in
- * that page. The want for that page goes through the page the cluster was found in: `SOURCE` is its row, `SOURCE_PAGE`
- * its own page index in the geometry, `REF` the entry of its child table naming the page, and `ERROR` the cluster's
- * projected error, as the want's priority (`vg_want`). A group held back carries no want, as in the cut, whose rule
- * leaves a held verdict's `REF` and `ERROR` at zero: the clamp beside it wants the page that holds it back.
- */
-export const VGEO_BRICK_WAIT_OFFSET: Readonly<{
-    KEY: 0;
-    LOOKUP: 1;
-    PAGE: 2;
-    GROUP: 3;
-    SOURCE: 4;
-    SOURCE_PAGE: 5;
-    REF: 6;
-    ERROR: 7;
-}>;
-/**
- * Words of a waiting cell.
- * @type {number}
- */
-export const VGEO_BRICK_WAIT_WORDS: number;
-/**
- * A taken cell's list: its header, then from `ENTRIES` a cluster's pair and meshlet row each. The header holds the
- * clusters taken (a count that runs past what the list holds), how many of them stood in for a page or a group not
- * there yet, and from `WAIT` the cell as a waiting cell's words ({@link VGEO_BRICK_WAIT_OFFSET}): its key, then the
- * first stand-in's wait, which the distances copy onto the waiting list whole.
- */
-export const VGEO_BRICK_CELL_OFFSET: Readonly<{
-    COUNT: 0;
-    WAITS: 1;
-    WAIT: 2;
-    KEY: number;
-    ENTRIES: number;
-}>;
-/**
- * Words of a taken cell's list.
- * @type {number}
- */
-export const VGEO_BRICK_CELL_WORDS: number;
-/**
- * Waiting cells the provider holds, for each cell of the take budget; past them, a cell that stood a cluster in is
- * dropped and counted, and is not built again when its page arrives.
- * @type {number}
- */
-export const VGEO_BRICK_WAITS_PER_CELL: number;
-/**
- * Triangles of a taken cell's cut that its distances are made from, in workgroup memory (§7.8, chosen): past
- * them, triangles are dropped and counted, and a dropped triangle can leave a hole. A texel's distance is a loop
- * over them.
- * @type {number}
- */
-export const VGEO_BRICK_CELL_TRIANGLES: number;
-/**
- * Lanes of the distance pass, a workgroup a taken cell: a lane a triangle, of as many of the cell's clusters at a
- * time as the lanes hold whole, then the cell's texels shared out evenly.
- * @type {number}
- */
-export const VGEO_BRICK_DISTANCE_WORKGROUP_SIZE: number;
-/**
- * Words of the provider's statistics, every one an atomic that accumulates: pairs dropped (the records were full,
- * or the instance's transform flattens it), candidates and subtrees the gather's query dropped, triangles the
- * distance pass dropped past {@link VGEO_BRICK_CELL_TRIANGLES}, and waiting cells dropped past the waiting list.
- */
-export const VGEO_BRICK_STATISTIC_PAIRS_DROPPED: 0;
-export const VGEO_BRICK_STATISTIC_CANDIDATES_DROPPED: 1;
-export const VGEO_BRICK_STATISTIC_NODES_DROPPED: 2;
-export const VGEO_BRICK_STATISTIC_TRIANGLES_DROPPED: 3;
-export const VGEO_BRICK_STATISTIC_WAITS_DROPPED: 4;
-export const VGEO_BRICK_STATISTIC_WORDS: 8;
-import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
-//# sourceMappingURL=VGEO_BRICK.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/VGEO_BRICK.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VGEO_BRICK.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/VGEO_BRICK.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,kCAFU,YAAY,CAWE;AAExB;;;;GAIG;AACH,kCAFU,MAAM,CAEgD;AAEhE;;;GAGG;AACH,oCAFU,MAAM,CAE8D;AAI9E;;;GAGG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,uCAFU,MAAM,CAE2B;AAE3C;;;;;;;GAOG;AACH;;;;;;;;;GASG;AAEH;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;;GAKG;AACH;;;;;;GAMG;AAEH;;;GAGG;AACH,oCAFU,MAAM,CAEmF;AAEnG;;;;GAIG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;GAKG;AACH,wCAFU,MAAM,CAE6B;AAE7C;;;;GAIG;AACH,iDAFU,MAAM,CAEsE;AAKtF;;;;GAIG;AACH,mDAAoD;AACpD,wDAAyD;AACzD,mDAAoD;AACpD,uDAAwD;AACxD,mDAAoD;AACpD,2CAA4C;6BApIf,yCAAyC"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/VGEO_BRICK.js

@@ -1,139 +0,0 @@
-import { assert } from "../../../../../../core/assert.js";
-import { MESH_SDF_BRICK_TEXEL_COUNT } from "../../../../geometry/sdf/MESH_SDF.js";
-import { VGEO_MAX_CLUSTER_TRIANGLE_COUNT } from "../../../../geometry/virtual/format/cluster/VGEO_MAX_CLUSTER_TRIANGLE_COUNT.js";
-import { VGEO_INSTANCE_OFFSET } from "../../../../geometry/virtual/runtime/layout/VGEO_INSTANCE_OFFSET.js";
-import { VGEO_INSTANCE_WORDS } from "../../../../geometry/virtual/runtime/layout/VGEO_INSTANCE_WORDS.js";
-import { u32 } from "../../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
-
-/*
- The vgeo brick provider's layouts (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8).
-
- A pair is a taken cell and a vgeo instance whose box reaches it. Its record is a cut's instance record
- (VGEO_INSTANCE_OFFSET), so the camera cut's seed and descent run it unchanged; what a view keeps for its own
- culls, the pair keeps for the box's.
-*/
-
-/**
- * The provider's settings, an immediate of each of its passes.
- * @type {WebGPUStruct}
- */
-export const VGEO_BRICK_SETTINGS = WebGPUStruct.from({
-    /** keys `brick_ring` holds, a power of two */
-    ring_capacity: u32,
-    /** cells a cascade's window has a side */
-    resolution: u32,
-    /** pair records the frame holds */
-    pair_capacity: u32,
-    /** waiting cells a waiting list holds */
-    wait_capacity: u32,
-}, "VGeoBrickSettings");
-
-/**
- * Where a pair record keeps the box it is cut against: the cell grown by the field's band, in the instance's
- * object space, lower xyz then upper xyz, in the words a view's record keeps its frustum in.
- * @type {number}
- */
-export const VGEO_BRICK_PAIR_BOX = VGEO_INSTANCE_OFFSET.FRUSTUM;
-
-/**
- * Where a pair record keeps its taken cell: the first word a view's record leaves free.
- * @type {number}
- */
-export const VGEO_BRICK_PAIR_BUILD = VGEO_INSTANCE_OFFSET.DISTANCE_WEIGHT + 1;
-
-assert.lessThan(VGEO_BRICK_PAIR_BUILD, VGEO_INSTANCE_WORDS, 'a pair record keeps its cell inside the record');
-
-/**
- * Pair records a frame holds, for each cell of its take budget; past them, pairs are dropped and counted.
- * @type {number}
- */
-export const VGEO_BRICK_PAIRS_PER_CELL = 8;
-
-/**
- * Clusters a taken cell's list holds; past them, clusters are dropped and counted.
- * @type {number}
- */
-export const VGEO_BRICK_CELL_CLUSTERS = 64;
-
-/**
- * A waiting cell: its key, then what the first cluster of its cut that stood something in waits on, and what wants
- * it. The page it waits on is `PAGE` of the geometry whose page lookup starts at `LOOKUP`, and `GROUP` is the group in
- * that page. The want for that page goes through the page the cluster was found in: `SOURCE` is its row, `SOURCE_PAGE`
- * its own page index in the geometry, `REF` the entry of its child table naming the page, and `ERROR` the cluster's
- * projected error, as the want's priority (`vg_want`). A group held back carries no want, as in the cut, whose rule
- * leaves a held verdict's `REF` and `ERROR` at zero: the clamp beside it wants the page that holds it back.
- */
-export const VGEO_BRICK_WAIT_OFFSET = Object.freeze({
-    KEY: 0,
-    LOOKUP: 1,
-    PAGE: 2,
-    GROUP: 3,
-    SOURCE: 4,
-    SOURCE_PAGE: 5,
-    REF: 6,
-    ERROR: 7,
-});
-
-/**
- * Words of a waiting cell.
- * @type {number}
- */
-export const VGEO_BRICK_WAIT_WORDS = 8;
-
-/**
- * A taken cell's list: its header, then from `ENTRIES` a cluster's pair and meshlet row each. The header holds the
- * clusters taken (a count that runs past what the list holds), how many of them stood in for a page or a group not
- * there yet, and from `WAIT` the cell as a waiting cell's words ({@link VGEO_BRICK_WAIT_OFFSET}): its key, then the
- * first stand-in's wait, which the distances copy onto the waiting list whole.
- */
-export const VGEO_BRICK_CELL_OFFSET = Object.freeze({
-    COUNT: 0,
-    WAITS: 1,
-    WAIT: 2,
-    KEY: 2 + VGEO_BRICK_WAIT_OFFSET.KEY,
-    ENTRIES: 2 + VGEO_BRICK_WAIT_WORDS,
-});
-
-/**
- * Words of a taken cell's list.
- * @type {number}
- */
-export const VGEO_BRICK_CELL_WORDS = VGEO_BRICK_CELL_OFFSET.ENTRIES + 2 * VGEO_BRICK_CELL_CLUSTERS;
-
-/**
- * Waiting cells the provider holds, for each cell of the take budget; past them, a cell that stood a cluster in is
- * dropped and counted, and is not built again when its page arrives.
- * @type {number}
- */
-export const VGEO_BRICK_WAITS_PER_CELL = 4;
-
-/**
- * Triangles of a taken cell's cut that its distances are made from, in workgroup memory (§7.8, chosen): past
- * them, triangles are dropped and counted, and a dropped triangle can leave a hole. A texel's distance is a loop
- * over them.
- * @type {number}
- */
-export const VGEO_BRICK_CELL_TRIANGLES = 256;
-
-/**
- * Lanes of the distance pass, a workgroup a taken cell: a lane a triangle, of as many of the cell's clusters at a
- * time as the lanes hold whole, then the cell's texels shared out evenly.
- * @type {number}
- */
-export const VGEO_BRICK_DISTANCE_WORKGROUP_SIZE = 2 * VGEO_MAX_CLUSTER_TRIANGLE_COUNT;
-
-assert.equal(MESH_SDF_BRICK_TEXEL_COUNT % VGEO_BRICK_DISTANCE_WORKGROUP_SIZE, 0, 'the distance pass shares a cell\'s texels out evenly');
-assert.lessThanOrEqual(VGEO_BRICK_DISTANCE_WORKGROUP_SIZE, 256, 'the distance pass\'s workgroup is within WebGPU\'s default invocation limit');
-
-/**
- * Words of the provider's statistics, every one an atomic that accumulates: pairs dropped (the records were full,
- * or the instance's transform flattens it), candidates and subtrees the gather's query dropped, triangles the
- * distance pass dropped past {@link VGEO_BRICK_CELL_TRIANGLES}, and waiting cells dropped past the waiting list.
- */
-export const VGEO_BRICK_STATISTIC_PAIRS_DROPPED = 0;
-export const VGEO_BRICK_STATISTIC_CANDIDATES_DROPPED = 1;
-export const VGEO_BRICK_STATISTIC_NODES_DROPPED = 2;
-export const VGEO_BRICK_STATISTIC_TRIANGLES_DROPPED = 3;
-export const VGEO_BRICK_STATISTIC_WAITS_DROPPED = 4;
-export const VGEO_BRICK_STATISTIC_WORDS = 8;