@woosh/meep-engine 3.57.0 → 3.58.0

package/src/shade/renderer/geometry/sdf/MESH_SDF.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The constants of a geometry's sparse distance field (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.2–6.3).
+ * Fixed, not settings: the brick clipmap's bricks share the layout, and every reader takes it as is.
+ */
+/**
+ * Voxels along a side of a brick. Its texels sit on the voxels' corners, so a brick is
+ * {@link MESH_SDF_BRICK_TEXELS} texels a side and its last texel repeats the next brick's first:
+ * every brick computes all of its own, and a trilinear tap never leaves its brick.
+ * @type {number}
+ */
+export const MESH_SDF_BRICK_VOXELS: number;
+/**
+ * Texels along a side of a brick: {@link MESH_SDF_BRICK_VOXELS} + 1.
+ * @type {number}
+ */
+export const MESH_SDF_BRICK_TEXELS: number;
+/**
+ * Texels in a brick: 512, one byte each.
+ * @type {number}
+ */
+export const MESH_SDF_BRICK_TEXEL_COUNT: number;
+/**
+ * The band, in voxels of the level: what a texel stores is the signed distance clamped to
+ * `±MESH_SDF_BAND_VOXELS` voxels, encoded `saturate(d / 2R + 0.5)` in `r8unorm`. One step of the
+ * encoding is 8/255 = 0.031 voxel. Unreal's mesh and global distance fields use the same band.
+ * @type {number}
+ */
+export const MESH_SDF_BAND_VOXELS: number;
+/**
+ * A brick's entry in the indirection when no texel of it is within the band, outside the surface: it
+ * reads as `+R`, and holds no slot. The high bit, so that no slot index reaches it: an entry at or
+ * past it holds no slot, and its bit 0 says which side of the surface it is on.
+ * @type {number}
+ */
+export const MESH_SDF_EMPTY: number;
+/**
+ * A brick's entry when no texel of it is within the band, inside the surface: it reads as `-R`.
+ * @type {number}
+ */
+export const MESH_SDF_EMPTY_INSIDE: number;
+/**
+ * What a geometry's header says about its field.
+ */
+export type MeshSDFState = number;
+/**
+ * What a geometry's header says about its field.
+ * @readonly
+ * @enum {number}
+ */
+export const MeshSDFState: Readonly<{
+    /** No field: nothing has asked for one, or it was given back. A fresh header reads so. */
+    None: 0;
+    /** Its bricks are being classified, evaluated and stored; readers take it as absent. */
+    Baking: 1;
+    /** Every brick is stored or EMPTY. */
+    Resident: 2;
+    /** It has no field of its own and reads its `source`'s: a skinned clone, read in its source's bind pose. */
+    Alias: 3;
+}>;
+//# sourceMappingURL=MESH_SDF.d.ts.map

package/src/shade/renderer/geometry/sdf/MESH_SDF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MESH_SDF.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/MESH_SDF.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,yCAFU,MAAM,CAEgG;AAEhH;;;;;GAKG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;;;GAKG;AACH,6BAFU,MAAM,CAEyB;AAEzC;;;GAGG;AACH,oCAFU,MAAM,CAEwC;;;;2BAK9C,MAAM;AAHhB;;;;GAIG;AACH;IACI,0FAA0F;;IAE1F,wFAAwF;;IAExF,sCAAsC;;IAEtC,4GAA4G;;GAE7G"}

package/src/shade/renderer/geometry/sdf/MESH_SDF.js

@@ -0,0 +1,62 @@
+/**
+ * The constants of a geometry's sparse distance field (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.2–6.3).
+ * Fixed, not settings: the brick clipmap's bricks share the layout, and every reader takes it as is.
+ */
+
+/**
+ * Voxels along a side of a brick. Its texels sit on the voxels' corners, so a brick is
+ * {@link MESH_SDF_BRICK_TEXELS} texels a side and its last texel repeats the next brick's first:
+ * every brick computes all of its own, and a trilinear tap never leaves its brick.
+ * @type {number}
+ */
+export const MESH_SDF_BRICK_VOXELS = 7;
+
+/**
+ * Texels along a side of a brick: {@link MESH_SDF_BRICK_VOXELS} + 1.
+ * @type {number}
+ */
+export const MESH_SDF_BRICK_TEXELS = 8;
+
+/**
+ * Texels in a brick: 512, one byte each.
+ * @type {number}
+ */
+export const MESH_SDF_BRICK_TEXEL_COUNT = MESH_SDF_BRICK_TEXELS * MESH_SDF_BRICK_TEXELS * MESH_SDF_BRICK_TEXELS;
+
+/**
+ * The band, in voxels of the level: what a texel stores is the signed distance clamped to
+ * `±MESH_SDF_BAND_VOXELS` voxels, encoded `saturate(d / 2R + 0.5)` in `r8unorm`. One step of the
+ * encoding is 8/255 = 0.031 voxel. Unreal's mesh and global distance fields use the same band.
+ * @type {number}
+ */
+export const MESH_SDF_BAND_VOXELS = 4;
+
+/**
+ * A brick's entry in the indirection when no texel of it is within the band, outside the surface: it
+ * reads as `+R`, and holds no slot. The high bit, so that no slot index reaches it: an entry at or
+ * past it holds no slot, and its bit 0 says which side of the surface it is on.
+ * @type {number}
+ */
+export const MESH_SDF_EMPTY = 0x80000000;
+
+/**
+ * A brick's entry when no texel of it is within the band, inside the surface: it reads as `-R`.
+ * @type {number}
+ */
+export const MESH_SDF_EMPTY_INSIDE = MESH_SDF_EMPTY + 1;
+
+/**
+ * What a geometry's header says about its field.
+ * @readonly
+ * @enum {number}
+ */
+export const MeshSDFState = Object.freeze({
+    /** No field: nothing has asked for one, or it was given back. A fresh header reads so. */
+    None: 0,
+    /** Its bricks are being classified, evaluated and stored; readers take it as absent. */
+    Baking: 1,
+    /** Every brick is stored or EMPTY. */
+    Resident: 2,
+    /** It has no field of its own and reads its `source`'s: a skinned clone, read in its source's bind pose. */
+    Alias: 3,
+});

package/src/shade/renderer/geometry/sdf/MESH_SDF_RESOURCES.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Every geometry's header, by geometry id.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_HEADERS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Every geometry's bricks, one word each: a slot of the atlas, or `MESH_SDF_EMPTY` or
+ * `MESH_SDF_EMPTY_INSIDE`, the side of the surface a brick with no texel within the band is on.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_INDIRECTION_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The bricks' texels: an `r8unorm` 3-D atlas of 8³ tiles, sampled with hardware trilinear filtering.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_ATLAS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Linear on every axis, clamped: a tap inside a brick never reaches past it, so the clamp is never
+ * what decides a texel.
+ * @type {SamplerDescriptor}
+ */
+export const MESH_SDF_SAMPLER: SamplerDescriptor;
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_SAMPLER_RESOURCE: ShaderResourceDescriptor;
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { SamplerDescriptor } from "../../../descriptor/texture/SamplerDescriptor.js";
+//# sourceMappingURL=MESH_SDF_RESOURCES.d.ts.map

package/src/shade/renderer/geometry/sdf/MESH_SDF_RESOURCES.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MESH_SDF_RESOURCES.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/MESH_SDF_RESOURCES.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH,wCAFU,wBAAwB,CAEqG;AAEvI;;;;GAIG;AACH,4CAFU,wBAAwB,CAE2F;AAE7H;;;GAGG;AACH,sCAFU,wBAAwB,CAEuE;AAEzG;;;;GAIG;AACH,+BAFU,iBAAiB,CAQvB;AAEJ;;GAEG;AACH,wCAFU,wBAAwB,CAE2F;yCAvCpF,mDAAmD;kCAD1D,kDAAkD"}

package/src/shade/renderer/geometry/sdf/MESH_SDF_RESOURCES.js

@@ -0,0 +1,41 @@
+import { SamplerDescriptor } from "../../../descriptor/texture/SamplerDescriptor.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { MESH_SDF_STRUCT } from "./MESH_SDF_STRUCT.js";
+
+/**
+ * Every geometry's header, by geometry id.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_HEADERS_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_sdf_headers", WebGPUArray.from(MESH_SDF_STRUCT));
+
+/**
+ * Every geometry's bricks, one word each: a slot of the atlas, or `MESH_SDF_EMPTY` or
+ * `MESH_SDF_EMPTY_INSIDE`, the side of the surface a brick with no texel within the band is on.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_INDIRECTION_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_sdf_indirection", WebGPUArray.u32);
+
+/**
+ * The bricks' texels: an `r8unorm` 3-D atlas of 8³ tiles, sampled with hardware trilinear filtering.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_ATLAS_RESOURCE = ShaderResourceDescriptor.texture("mesh_sdf_atlas", "float", "3d");
+
+/**
+ * Linear on every axis, clamped: a tap inside a brick never reaches past it, so the clamp is never
+ * what decides a texel.
+ * @type {SamplerDescriptor}
+ */
+export const MESH_SDF_SAMPLER = Object.freeze(SamplerDescriptor.from({
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+    addressModeW: "clamp-to-edge",
+}));
+
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler("mesh_sdf_sampler", "filtering", MESH_SDF_SAMPLER);

package/src/shade/renderer/geometry/sdf/MESH_SDF_STRUCT.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A geometry's sparse distance field, as readers find it: one header per geometry id
+ * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.3). Its layout is {@link MeshSDFLayout}'s; its bricks are
+ * the indirection's entries from `indirection` on, level after level.
+ *
+ * 64 bytes.
+ *
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=MESH_SDF_STRUCT.d.ts.map

package/src/shade/renderer/geometry/sdf/MESH_SDF_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MESH_SDF_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/MESH_SDF_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,8BAFU,YAAY,CA0CR;6BAnDe,mCAAmC"}

package/src/shade/renderer/geometry/sdf/MESH_SDF_STRUCT.js

@@ -0,0 +1,53 @@
+import { f32, u32, vec3f, vec3u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * A geometry's sparse distance field, as readers find it: one header per geometry id
+ * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.3). Its layout is {@link MeshSDFLayout}'s; its bricks are
+ * the indirection's entries from `indirection` on, level after level.
+ *
+ * 64 bytes.
+ *
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_STRUCT = WebGPUStruct.from({
+    /**
+     * The grid's smallest corner, the geometry's local units. Every level starts there.
+     */
+    origin: vec3f,
+    /**
+     * Level 0's voxel; level k's is `voxel · 2^k`.
+     */
+    voxel: f32,
+    /**
+     * Level 0's bricks along x, y and z; level k has `⌈bricks / 2^k⌉`.
+     */
+    bricks: vec3u,
+    level_count: u32,
+    /**
+     * The first entry of level 0 in the indirection.
+     */
+    indirection: u32,
+    /**
+     * The first word of the geometry's card layout, `GPU_DATABASE_NULL` until its cards are placed.
+     */
+    cards: u32,
+    /**
+     * `MeshSDFState`.
+     */
+    state: u32,
+    /**
+     * The geometry id whose field this one reads, when `state` is `MeshSDFState.Alias`. Not named
+     * `alias`, which is a WGSL keyword.
+     */
+    source: u32,
+    /**
+     * Counts the bakes of this id, so that a brick queued for one bake is not stored into the next.
+     */
+    generation: u32,
+    /**
+     * 1 when the field was baked for a holder that draws both sides: its vote counted no back face,
+     * so nothing is inside it.
+     */
+    two_sided: u32,
+}, "MeshSDF");

package/src/shade/renderer/geometry/sdf/MeshSDFLayout.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Where a geometry's sparse distance field sits and how it is cut (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md
+ * §6.2), in the geometry's local units.
+ *
+ * **The grid box** is the geometry's bounds grown by the band, R = {@link MESH_SDF_BAND_VOXELS}
+ * voxels, on every side, so that the band fits. **Bricks per axis** are
+ * `max(2, 2·⌈E / 14v⌉)` for an extent E of that box: the size classes, two bricks at least and then
+ * steps of two, each axis on its own. Even counts make the first coarser level exact, and the
+ * minimum leaves a one-brick level. The bricks cover more than the box by up to two bricks a side;
+ * the spare voxels pad both sides evenly, so the bounds sit at least R inside the grid.
+ *
+ * **Past the cap** (`max_bricks` along the longest axis) the voxel grows until that axis fits, so the
+ * geometry is coarser than asked, which {@link coarsened} says. At the default voxel of 0.125 and the
+ * default cap of 18 bricks (126 voxels, 15.75 units of grid), that is a geometry more than 14.75 units
+ * across: the band takes 8 voxels of the grid.
+ *
+ * **Levels**: level k has voxel `v·2^k` and `⌈b / 2^k⌉` bricks along an axis of `b`, down to one brick
+ * along every axis: `1 + ⌈log₂ max b⌉` levels. Every level starts at the same corner.
+ *
+ * Its bricks are indexed level after level, each level x fastest, then y, then z: the order of the
+ * geometry's indirection, so a brick's index is its entry's offset from the geometry's first.
+ */
+export class MeshSDFLayout {
+    /**
+     * The grid's smallest corner, local units.
+     * @type {Float64Array}
+     */
+    origin: Float64Array;
+    /**
+     * Level 0's voxel, local units.
+     * @type {number}
+     */
+    voxel: number;
+    /**
+     * Level 0's bricks along x, y and z.
+     * @type {Int32Array}
+     */
+    bricks: Int32Array;
+    /**
+     * @type {number}
+     */
+    level_count: number;
+    /**
+     * Whether the voxel had to grow past the one asked for, to keep within the cap.
+     * @type {boolean}
+     */
+    coarsened: boolean;
+    /**
+     * Bricks of every level together: the entries the geometry's indirection holds.
+     * @type {number}
+     */
+    brick_count: number;
+    /**
+     * @param {number} level
+     * @param {number} axis 0, 1 or 2
+     * @returns {number} the level's bricks along the axis
+     */
+    level_bricks(level: number, axis: number): number;
+    /**
+     * @param {number} level
+     * @returns {number} the level's bricks
+     */
+    level_brick_count(level: number): number;
+    /**
+     * @param {number} level
+     * @returns {number} the index of the level's first brick among the geometry's
+     */
+    level_offset(level: number): number;
+    /**
+     * Cut the field for a geometry.
+     *
+     * @param {ArrayLike<number>} bounds the geometry's box: min x, y, z, then max x, y, z, local units
+     * @param {number} voxel_size the voxel asked for, local units
+     * @param {number} max_bricks bricks along an axis before the voxel grows, even and at least 2
+     * @returns {MeshSDFLayout} this
+     */
+    compute(bounds: ArrayLike<number>, voxel_size: number, max_bricks: number): MeshSDFLayout;
+}
+//# sourceMappingURL=MeshSDFLayout.d.ts.map

package/src/shade/renderer/geometry/sdf/MeshSDFLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeshSDFLayout.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/MeshSDFLayout.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IACI;;;OAGG;IACH,QAFU,YAAY,CAEO;IAE7B;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,UAAU,CAEO;IAE3B;;OAEG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,WAFU,OAAO,CAEC;IAElB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,oBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;;;OAOG;IACH,gBALW,UAAU,MAAM,CAAC,cACjB,MAAM,cACN,MAAM,GACJ,aAAa,CAuDzB;CACJ"}

package/src/shade/renderer/geometry/sdf/MeshSDFLayout.js

@@ -0,0 +1,168 @@
+import { assert } from "../../../../core/assert.js";
+import { MESH_SDF_BAND_VOXELS, MESH_SDF_BRICK_VOXELS } from "./MESH_SDF.js";
+
+/**
+ * Where a geometry's sparse distance field sits and how it is cut (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md
+ * §6.2), in the geometry's local units.
+ *
+ * **The grid box** is the geometry's bounds grown by the band, R = {@link MESH_SDF_BAND_VOXELS}
+ * voxels, on every side, so that the band fits. **Bricks per axis** are
+ * `max(2, 2·⌈E / 14v⌉)` for an extent E of that box: the size classes, two bricks at least and then
+ * steps of two, each axis on its own. Even counts make the first coarser level exact, and the
+ * minimum leaves a one-brick level. The bricks cover more than the box by up to two bricks a side;
+ * the spare voxels pad both sides evenly, so the bounds sit at least R inside the grid.
+ *
+ * **Past the cap** (`max_bricks` along the longest axis) the voxel grows until that axis fits, so the
+ * geometry is coarser than asked, which {@link coarsened} says. At the default voxel of 0.125 and the
+ * default cap of 18 bricks (126 voxels, 15.75 units of grid), that is a geometry more than 14.75 units
+ * across: the band takes 8 voxels of the grid.
+ *
+ * **Levels**: level k has voxel `v·2^k` and `⌈b / 2^k⌉` bricks along an axis of `b`, down to one brick
+ * along every axis: `1 + ⌈log₂ max b⌉` levels. Every level starts at the same corner.
+ *
+ * Its bricks are indexed level after level, each level x fastest, then y, then z: the order of the
+ * geometry's indirection, so a brick's index is its entry's offset from the geometry's first.
+ */
+export class MeshSDFLayout {
+    /**
+     * The grid's smallest corner, local units.
+     * @type {Float64Array}
+     */
+    origin = new Float64Array(3);
+
+    /**
+     * Level 0's voxel, local units.
+     * @type {number}
+     */
+    voxel = 0;
+
+    /**
+     * Level 0's bricks along x, y and z.
+     * @type {Int32Array}
+     */
+    bricks = new Int32Array(3);
+
+    /**
+     * @type {number}
+     */
+    level_count = 0;
+
+    /**
+     * Whether the voxel had to grow past the one asked for, to keep within the cap.
+     * @type {boolean}
+     */
+    coarsened = false;
+
+    /**
+     * Bricks of every level together: the entries the geometry's indirection holds.
+     * @type {number}
+     */
+    brick_count = 0;
+
+    /**
+     * @param {number} level
+     * @param {number} axis 0, 1 or 2
+     * @returns {number} the level's bricks along the axis
+     */
+    level_bricks(level, axis) {
+        const scale = 2 ** level;
+
+        return Math.ceil(this.bricks[axis] / scale);
+    }
+
+    /**
+     * @param {number} level
+     * @returns {number} the level's bricks
+     */
+    level_brick_count(level) {
+        return this.level_bricks(level, 0) * this.level_bricks(level, 1) * this.level_bricks(level, 2);
+    }
+
+    /**
+     * @param {number} level
+     * @returns {number} the index of the level's first brick among the geometry's
+     */
+    level_offset(level) {
+        let offset = 0;
+
+        for (let k = 0; k < level; k++) {
+            offset += this.level_brick_count(k);
+        }
+
+        return offset;
+    }
+
+    /**
+     * Cut the field for a geometry.
+     *
+     * @param {ArrayLike<number>} bounds the geometry's box: min x, y, z, then max x, y, z, local units
+     * @param {number} voxel_size the voxel asked for, local units
+     * @param {number} max_bricks bricks along an axis before the voxel grows, even and at least 2
+     * @returns {MeshSDFLayout} this
+     */
+    compute(bounds, voxel_size, max_bricks) {
+        assert.isFinite(voxel_size, 'voxel_size');
+        assert.greaterThan(voxel_size, 0, 'voxel_size');
+        assert.isPositiveInteger(max_bricks, 'max_bricks');
+        assert.greaterThanOrEqual(max_bricks, 2, 'max_bricks');
+        assert.equal(max_bricks % 2, 0, 'max_bricks must be even');
+
+        let span = 0;
+
+        for (let axis = 0; axis < 3; axis++) {
+            assert.isFinite(bounds[axis], 'bounds');
+            assert.isFinite(bounds[axis + 3], 'bounds');
+            assert.lessThanOrEqual(bounds[axis], bounds[axis + 3], 'bounds: min past max');
+
+            span = Math.max(span, bounds[axis + 3] - bounds[axis]);
+        }
+
+        // The longest axis fits the cap at a voxel of span / (7·max − 2·R): its extent span + 2Rv is
+        // then exactly max bricks of 7v. Below that voxel it would take more.
+        let voxel = Math.max(voxel_size, span / (MESH_SDF_BRICK_VOXELS * max_bricks - 2 * MESH_SDF_BAND_VOXELS));
+
+        // the bound is exact in reals; let rounding not tip the longest axis past the cap
+        while (bricks_along(span, voxel) > max_bricks) {
+            voxel *= 1 + 2 ** -20;
+        }
+
+        this.voxel = voxel;
+        this.coarsened = voxel > voxel_size;
+
+        let longest = 0;
+
+        for (let axis = 0; axis < 3; axis++) {
+            const extent = bounds[axis + 3] - bounds[axis];
+            const bricks = bricks_along(extent, voxel);
+            const centre = (bounds[axis] + bounds[axis + 3]) * 0.5;
+
+            this.bricks[axis] = bricks;
+            this.origin[axis] = centre - bricks * MESH_SDF_BRICK_VOXELS * voxel * 0.5;
+
+            longest = Math.max(longest, bricks);
+        }
+
+        this.level_count = 1 + Math.ceil(Math.log2(longest));
+
+        let total = 0;
+
+        for (let level = 0; level < this.level_count; level++) {
+            total += this.level_brick_count(level);
+        }
+
+        this.brick_count = total;
+
+        return this;
+    }
+}
+
+/**
+ * @param {number} span the bounds' extent along an axis
+ * @param {number} voxel
+ * @returns {number} bricks along it: the extent grown by the band on both sides, in pairs of bricks
+ */
+function bricks_along(span, voxel) {
+    const extent = span + 2 * MESH_SDF_BAND_VOXELS * voxel;
+
+    return Math.max(2, 2 * Math.ceil(extent / (2 * MESH_SDF_BRICK_VOXELS * voxel)));
+}

package/src/shade/renderer/geometry/sdf/bake/MESH_SDF_BAKE.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Lanes of every bake workgroup: a block of a brick's texels in evaluate and store, and a run of
+ * classify or free threads.
+ * @type {number}
+ */
+export const MESH_SDF_BAKE_WORKGROUP_SIZE: number;
+/**
+ * Evaluate and store workgroups per brick: its texels, one a thread.
+ * @type {number}
+ */
+export const MESH_SDF_GROUPS_PER_BRICK: number;
+/**
+ * A brick's texels as staged between evaluate and store, a word a texel, so that no two threads
+ * write one word.
+ * @type {number}
+ */
+export const MESH_SDF_STAGING_WORDS: number;
+/**
+ * The same, in the ring's `vec4<u32>` entries.
+ * @type {number}
+ */
+export const MESH_SDF_STAGING_VEC4S: number;
+/**
+ * The distance from a brick's centre to its farthest texel, in the level's voxels: 3.5·√3 = 6.0622,
+ * rounded up to a sixteenth, so that float rounding never brings a texel in reach of the band past
+ * what classify allowed for.
+ * @type {number}
+ */
+export const MESH_SDF_BRICK_HALF_DIAGONAL: number;
+/** The arena's counters, from word 0: free slots on the stack. */
+export const MESH_SDF_COUNTER_SLOTS: 0;
+/** The arena's counters: the ring position take has consumed up to. */
+export const MESH_SDF_COUNTER_HEAD: 1;
+/** The arena's counters: the ring position classify appends at. */
+export const MESH_SDF_COUNTER_TAIL: 2;
+/** The arena's counters, in words: its first allocation. */
+export const MESH_SDF_COUNTER_WORDS: 4;
+/** `take`: the dispatch of evaluate and of store, three words: MESH_SDF_GROUPS_PER_BRICK a brick taken. */
+export const MESH_SDF_TAKE_DISPATCH: 0;
+/** `take`: the ring position of the first brick taken. */
+export const MESH_SDF_TAKE_START: 3;
+/** `take`: the dispatch of card placement's page pass, three words: a thread a column, as its merge found. */
+export const MESH_SDF_TAKE_PLACE_DISPATCH: 4;
+/** `take`, in words. */
+export const MESH_SDF_TAKE_WORDS: 8;
+/** `log`: bricks left on the ring after the frame's take, stale ones included. */
+export const MESH_SDF_LOG_QUEUED: 0;
+/** `log`: 1 when the take was held back by the free slots, which asks the host for more. */
+export const MESH_SDF_LOG_STARVED: 1;
+/** `log`: free slots before the take. */
+export const MESH_SDF_LOG_FREE_SLOTS: 2;
+/** `log`: bricks the take handed to evaluate. */
+export const MESH_SDF_LOG_TAKEN: 3;
+/** `log`: geometries completed this frame; their records follow the header. */
+export const MESH_SDF_LOG_COMPLETIONS: 4;
+/** `log`: words before the first record. */
+export const MESH_SDF_LOG_HEADER_WORDS: 5;
+/**
+ * `log`: words a record: the geometry id, the generation it was baked at, and what the record
+ * reports. A completion reports nothing; a placement, marked by MESH_SDF_LOG_PLACED on the id,
+ * reports the columns and the pages its cards took.
+ */
+export const MESH_SDF_LOG_RECORD_WORDS: 4;
+/**
+ * `log`: the mark on a record's geometry id that says its cards were placed. Geometry ids stay below it.
+ * @type {number}
+ */
+export const MESH_SDF_LOG_PLACED: number;
+/**
+ * A tally, a workgroup's of its lanes and a brick's of its workgroups: the low half counts those
+ * finished, the high half those with a texel within the band, in this unit.
+ * @type {number}
+ */
+export const MESH_SDF_TALLY_BAND_UNIT: number;
+//# sourceMappingURL=MESH_SDF_BAKE.d.ts.map

package/src/shade/renderer/geometry/sdf/bake/MESH_SDF_BAKE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MESH_SDF_BAKE.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/MESH_SDF_BAKE.js"],"names":[],"mappings":"AA2BA;;;;GAIG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,wCAFU,MAAM,CAEmF;AAEnG;;;;GAIG;AACH,qCAFU,MAAM,CAEiD;AAEjE;;;GAGG;AACH,qCAFU,MAAM,CAEiD;AAEjE;;;;;GAKG;AACH,2CAFU,MAAM,CAE0F;AAE1G,kEAAkE;AAClE,uCAAwC;AACxC,uEAAuE;AACvE,sCAAuC;AACvC,mEAAmE;AACnE,sCAAuC;AACvC,4DAA4D;AAC5D,uCAAwC;AAExC,2GAA2G;AAC3G,uCAAwC;AACxC,0DAA0D;AAC1D,oCAAqC;AACrC,8GAA8G;AAC9G,6CAA8C;AAC9C,wBAAwB;AACxB,oCAAqC;AAErC,kFAAkF;AAClF,oCAAqC;AACrC,4FAA4F;AAC5F,qCAAsC;AACtC,yCAAyC;AACzC,wCAAyC;AACzC,iDAAiD;AACjD,mCAAoC;AACpC,+EAA+E;AAC/E,yCAA0C;AAC1C,4CAA4C;AAC5C,0CAA2C;AAC3C;;;;GAIG;AACH,0CAA2C;AAE3C;;;GAGG;AACH,kCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,uCAFU,MAAM,CAE8B"}