@driftengine/core 4.5.0 → 4.6.0

package/dist/geometry/solidHarness.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Checks a closed surface can be held to, for the solid and CSG tests.
+ *
+ * **Not a `.test.ts` file**, for the reason `rendererHarness.ts` gives: Vitest registers a test
+ * when the file declaring it is imported, so helpers living beside tests would re-run them in every
+ * file that imported them.
+ *
+ * `edgesPairOnce` welds by position and asks that every edge be shared by exactly two triangles
+ * running opposite ways, which is what closed and consistently wound means. `normalsFaceOutward`
+ * asks that every vertex normal lie on the outward side of its triangle. The matrices are
+ * column-major, as `transformSolid` takes them.
+ */
+import type { Solid } from './solid.ts';
+export declare function edgesPairOnce(solid: Solid): boolean;
+export declare function normalsFaceOutward(solid: Solid): boolean;
+export declare function translation(x: number, y: number, z: number): number[];
+export declare function scaling(x: number, y: number, z: number): number[];
+export declare function rotationX(a: number): number[];
+export declare function rotationY(a: number): number[];

package/dist/geometry/solidHarness.js

@@ -0,0 +1,66 @@
+export function edgesPairOnce(solid) {
+    const p = solid.positions;
+    const key = (i) => `${Math.round((p[i * 3] ?? 0) * 1e5)},${Math.round((p[i * 3 + 1] ?? 0) * 1e5)},${Math.round((p[i * 3 + 2] ?? 0) * 1e5)}`;
+    const directed = new Map();
+    const idx = solid.indices;
+    for (let t = 0; t < idx.length; t += 3) {
+        for (let e = 0; e < 3; e++) {
+            const a = key(idx[t + e] ?? 0);
+            const b = key(idx[t + ((e + 1) % 3)] ?? 0);
+            if (a === b)
+                continue;
+            const k = `${a}>${b}`;
+            directed.set(k, (directed.get(k) ?? 0) + 1);
+        }
+    }
+    for (const [k, n] of directed) {
+        const [a, b] = k.split('>');
+        if (n !== 1 || directed.get(`${b}>${a}`) !== 1)
+            return false;
+    }
+    return directed.size > 0;
+}
+export function normalsFaceOutward(solid) {
+    const p = solid.positions;
+    const n = solid.normals;
+    const idx = solid.indices;
+    const at = (i, c) => p[i * 3 + c] ?? 0;
+    for (let t = 0; t < idx.length; t += 3) {
+        const a = idx[t] ?? 0;
+        const b = idx[t + 1] ?? 0;
+        const c = idx[t + 2] ?? 0;
+        const ux = at(b, 0) - at(a, 0);
+        const uy = at(b, 1) - at(a, 1);
+        const uz = at(b, 2) - at(a, 2);
+        const vx = at(c, 0) - at(a, 0);
+        const vy = at(c, 1) - at(a, 1);
+        const vz = at(c, 2) - at(a, 2);
+        const gx = uy * vz - uz * vy;
+        const gy = uz * vx - ux * vz;
+        const gz = ux * vy - uy * vx;
+        if (Math.hypot(gx, gy, gz) < 1e-12)
+            continue;
+        for (const v of [a, b, c]) {
+            if (gx * (n[v * 3] ?? 0) + gy * (n[v * 3 + 1] ?? 0) + gz * (n[v * 3 + 2] ?? 0) <= 0) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+export function translation(x, y, z) {
+    return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z, 1];
+}
+export function scaling(x, y, z) {
+    return [x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1];
+}
+export function rotationX(a) {
+    const c = Math.cos(a);
+    const s = Math.sin(a);
+    return [1, 0, 0, 0, 0, c, s, 0, 0, -s, c, 0, 0, 0, 0, 1];
+}
+export function rotationY(a) {
+    const c = Math.cos(a);
+    const s = Math.sin(a);
+    return [c, 0, -s, 0, 0, 1, 0, 0, s, 0, c, 0, 0, 0, 0, 1];
+}

package/dist/geometry/solidNormals.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Crease-angle normal smoothing: every vertex takes the average of the faces meeting at its
+ * position whose normals lie within the crease angle of its own, so a cylinder's side goes round
+ * while its rim stays sharp.
+ *
+ * **Weighted by the corner angle each face makes at the vertex, not by area.** A quad split into
+ * two triangles meets a vertex with one triangle at one corner and two at the next, so area weights
+ * favour whichever side the split fell on and lean every normal of a smooth side a degree or two off
+ * true. The corner angle a quad makes is 90° however it was split, which is what makes the average
+ * belong to the shape rather than to its triangulation.
+ *
+ * Positions are welded at 1e-5 for the lookup only; the solid keeps its vertices, indices and
+ * texture coordinates, and each vertex's incoming normal chooses which faces it joins — so a
+ * faceted solid's own face normals decide the creases.
+ */
+import type { Solid } from './solid.ts';
+export declare function smoothSolidNormals(solid: Solid, creaseDeg: number): Solid;

package/dist/geometry/solidNormals.js

@@ -0,0 +1,86 @@
+export function smoothSolidNormals(solid, creaseDeg) {
+    const p = solid.positions;
+    const idx = solid.indices;
+    const count = p.length / 3;
+    const cosCrease = Math.cos((creaseDeg * Math.PI) / 180);
+    const weld = new Map();
+    const group = new Int32Array(count);
+    for (let v = 0; v < count; v++) {
+        const key = `${Math.round((p[v * 3] ?? 0) * 1e5)},${Math.round((p[v * 3 + 1] ?? 0) * 1e5)},${Math.round((p[v * 3 + 2] ?? 0) * 1e5)}`;
+        let id = weld.get(key);
+        if (id === undefined) {
+            id = weld.size;
+            weld.set(key, id);
+        }
+        group[v] = id;
+    }
+    /* For each welded position, the faces meeting there: unit normal and the corner angle. */
+    const corners = Array.from({ length: weld.size }, () => []);
+    for (let t = 0; t < idx.length; t += 3) {
+        const ids = [idx[t] ?? 0, idx[t + 1] ?? 0, idx[t + 2] ?? 0];
+        const at = (i, c) => p[(ids[i] ?? 0) * 3 + c] ?? 0;
+        const ux = at(1, 0) - at(0, 0);
+        const uy = at(1, 1) - at(0, 1);
+        const uz = at(1, 2) - at(0, 2);
+        const vx = at(2, 0) - at(0, 0);
+        const vy = at(2, 1) - at(0, 1);
+        const vz = at(2, 2) - at(0, 2);
+        let nx = uy * vz - uz * vy;
+        let ny = uz * vx - ux * vz;
+        let nz = ux * vy - uy * vx;
+        const len = Math.hypot(nx, ny, nz);
+        if (len < 1e-12)
+            continue;
+        nx /= len;
+        ny /= len;
+        nz /= len;
+        for (let k = 0; k < 3; k++) {
+            const o = (k + 1) % 3;
+            const q = (k + 2) % 3;
+            const ax = at(o, 0) - at(k, 0);
+            const ay = at(o, 1) - at(k, 1);
+            const az = at(o, 2) - at(k, 2);
+            const bx = at(q, 0) - at(k, 0);
+            const by = at(q, 1) - at(k, 1);
+            const bz = at(q, 2) - at(k, 2);
+            const denom = Math.hypot(ax, ay, az) * Math.hypot(bx, by, bz) || 1;
+            const angle = Math.acos(Math.max(-1, Math.min(1, (ax * bx + ay * by + az * bz) / denom)));
+            corners[group[ids[k] ?? 0] ?? 0]?.push(nx, ny, nz, angle);
+        }
+    }
+    const normals = new Float32Array(count * 3);
+    for (let v = 0; v < count; v++) {
+        const own = [
+            solid.normals[v * 3] ?? 0,
+            solid.normals[v * 3 + 1] ?? 0,
+            solid.normals[v * 3 + 2] ?? 0,
+        ];
+        const list = corners[group[v] ?? 0] ?? [];
+        let sx = 0;
+        let sy = 0;
+        let sz = 0;
+        for (let c = 0; c < list.length; c += 4) {
+            const fx = list[c] ?? 0;
+            const fy = list[c + 1] ?? 0;
+            const fz = list[c + 2] ?? 0;
+            if (fx * (own[0] ?? 0) + fy * (own[1] ?? 0) + fz * (own[2] ?? 0) < cosCrease)
+                continue;
+            const w = list[c + 3] ?? 0;
+            sx += fx * w;
+            sy += fy * w;
+            sz += fz * w;
+        }
+        const len = Math.hypot(sx, sy, sz);
+        if (len < 1e-12) {
+            normals[v * 3] = own[0] ?? 0;
+            normals[v * 3 + 1] = own[1] ?? 0;
+            normals[v * 3 + 2] = own[2] ?? 0;
+        }
+        else {
+            normals[v * 3] = sx / len;
+            normals[v * 3 + 1] = sy / len;
+            normals[v * 3 + 2] = sz / len;
+        }
+    }
+    return { positions: solid.positions, normals, uvs: solid.uvs, indices: solid.indices };
+}

package/dist/geometry/solidRound.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The round solids: cylinder, cone, frustum, tube, sphere, hemisphere, icosphere, capsule, torus
+ * and lathe — all but the icosphere one revolve of a profile around +Y.
+ *
+ * A profile is `(r, y)` points. Revolving it, the vertex at angle θ sits at (r·cos θ, y, r·sin θ),
+ * and a quad is wound so that the profile's direction crossed with the direction of increasing θ
+ * points outward: a profile climbing on its outer side, or running outward along a bottom cap,
+ * faces out. Where the profile touches the axis a quad collapses to a triangle and only the
+ * triangle is written, so no edge is counted twice.
+ *
+ * `smooth` shares vertices around the axis with normals that vary around it; the default,
+ * faceted, gives every quad its own four vertices and its own normal. Texture u runs around (0..1,
+ * the seam duplicated) and v along the profile (0..1 by length).
+ */
+import type { Solid } from './solid.ts';
+/** A cylinder of `radius` and `length` along Y, centred, capped. */
+export declare function solidCylinder(radius: number, length: number, segments: number, smooth?: boolean): Solid;
+/** A cone: base `radius` at −length/2, apex at +length/2. */
+export declare function solidCone(radius: number, length: number, segments: number, smooth?: boolean): Solid;
+/** A frustum with explicit radii at its bottom (−length/2) and top (+length/2), capped. */
+export declare function solidFrustum(radiusBottom: number, radiusTop: number, length: number, segments: number, smooth?: boolean): Solid;
+/** A hollow cylinder: outer `radius`, wall `thickness`, `length` along Y, centred. Four segments make a square frame. */
+export declare function solidTube(radius: number, thickness: number, length: number, segments: number, smooth?: boolean): Solid;
+/** A sphere of `radius`: `segments` around, half as many from pole to pole. */
+export declare function solidSphere(radius: number, segments: number, smooth?: boolean): Solid;
+/** A dome toward +Y on a flat base at the origin. */
+export declare function solidHemisphere(radius: number, segments: number, smooth?: boolean): Solid;
+/** A capsule: a cylinder of `length` (excluding the caps) with hemispherical ends, along Y. */
+export declare function solidCapsule(radius: number, length: number, segments: number, smooth?: boolean): Solid;
+/** A torus around +Y: ring radius `major`, tube radius `minor`, `segments` around and `sides` across. */
+export declare function solidTorus(major: number, minor: number, segments: number, sides: number, smooth?: boolean): Solid;
+/**
+ * A profile (`r, y` pairs, bottom to top) revolved around +Y. An end off the axis is closed with a
+ * flat cap, so any profile makes a solid. Every profile corner creases, faceted or smooth.
+ */
+export declare function solidLathe(profile: ArrayLike<number>, segments: number, smooth?: boolean): Solid;
+/**
+ * An icosahedron subdivided `level` times onto a sphere of `radius`. Faceted by default — every
+ * triangle its own vertices and face normal — or smooth, sharing vertices with radial normals.
+ */
+export declare function solidIcosphere(radius: number, level: number, smooth?: boolean): Solid;

package/dist/geometry/solidRound.js

@@ -0,0 +1,323 @@
+import { SolidWriter } from './solidWriter.js';
+/**
+ * Revolve one or more strips — runs of profile points whose normals are continuous — around +Y.
+ * A strip's normals are used when smooth; faceted quads take the normal their corners imply.
+ */
+function revolve(strips, segments, smooth) {
+    const n = Math.max(3, Math.floor(segments));
+    const out = new SolidWriter();
+    let total = 0;
+    for (const strip of strips) {
+        for (let i = 0; i + 1 < strip.length; i++)
+            total += span(strip[i], strip[i + 1]);
+    }
+    let walked = 0;
+    for (const strip of strips) {
+        const v = [];
+        for (let i = 0; i < strip.length; i++) {
+            if (i > 0)
+                walked += span(strip[i - 1], strip[i]);
+            v.push(total > 0 ? walked / total : 0);
+        }
+        if (smooth)
+            revolveSmooth(out, strip, v, n);
+        else
+            revolveFaceted(out, strip, v, n);
+    }
+    return out.finish();
+}
+function span(a, b) {
+    return a && b ? Math.hypot(b.r - a.r, b.y - a.y) : 0;
+}
+function revolveSmooth(out, strip, v, n) {
+    const base = out.vertexCount;
+    const row = n + 1;
+    for (let i = 0; i < strip.length; i++) {
+        const p = strip[i];
+        if (!p)
+            continue;
+        for (let j = 0; j <= n; j++) {
+            const t = (2 * Math.PI * (j % n)) / n;
+            const c = Math.cos(t);
+            const s = Math.sin(t);
+            out.vertex(p.r * c, p.y, p.r * s, p.nr * c, p.ny, p.nr * s, j / n, v[i] ?? 0);
+        }
+    }
+    for (let i = 0; i + 1 < strip.length; i++) {
+        const r0 = strip[i]?.r ?? 0;
+        const r1 = strip[i + 1]?.r ?? 0;
+        for (let j = 0; j < n; j++) {
+            const a = base + i * row + j;
+            const b = a + row;
+            const c = b + 1;
+            const d = a + 1;
+            emit(out, a, b, c, d, r0, r1);
+        }
+    }
+}
+function revolveFaceted(out, strip, v, n) {
+    for (let i = 0; i + 1 < strip.length; i++) {
+        const p = strip[i];
+        const q = strip[i + 1];
+        if (!p || !q)
+            continue;
+        for (let j = 0; j < n; j++) {
+            const t0 = (2 * Math.PI * j) / n;
+            const t1 = (2 * Math.PI * ((j + 1) % n)) / n;
+            const c0 = Math.cos(t0);
+            const s0 = Math.sin(t0);
+            const c1 = Math.cos(t1);
+            const s1 = Math.sin(t1);
+            const ax = p.r * c0;
+            const az = p.r * s0;
+            const bx = q.r * c0;
+            const bz = q.r * s0;
+            const cx = q.r * c1;
+            const cz = q.r * s1;
+            const dx = p.r * c1;
+            const dz = p.r * s1;
+            /* The normal from the diagonals, (c − a) × (d − b): right for a quad and for the triangle a
+               quad collapses to at the axis, where the edge-based cross product is zero. */
+            const ex = cx - ax;
+            const ey = q.y - p.y;
+            const ez = cz - az;
+            const fx = dx - bx;
+            const fy = p.y - q.y;
+            const fz = dz - bz;
+            let nx = ey * fz - ez * fy;
+            let ny = ez * fx - ex * fz;
+            let nz = ex * fy - ey * fx;
+            const len = Math.hypot(nx, ny, nz) || 1;
+            nx /= len;
+            ny /= len;
+            nz /= len;
+            const u0 = j / n;
+            const u1 = (j + 1) / n;
+            const a = out.vertex(ax, p.y, az, nx, ny, nz, u0, v[i] ?? 0);
+            const b = out.vertex(bx, q.y, bz, nx, ny, nz, u0, v[i + 1] ?? 0);
+            const c = out.vertex(cx, q.y, cz, nx, ny, nz, u1, v[i + 1] ?? 0);
+            const d = out.vertex(dx, p.y, dz, nx, ny, nz, u1, v[i] ?? 0);
+            emit(out, a, b, c, d, p.r, q.r);
+        }
+    }
+}
+/** Quad `a b c d`, or the one triangle left of it where either end of the profile step is on the axis. */
+function emit(out, a, b, c, d, r0, r1) {
+    if (r0 <= 1e-12 && r1 <= 1e-12)
+        return;
+    if (r0 <= 1e-12)
+        out.triangle(a, b, c);
+    else if (r1 <= 1e-12)
+        out.triangle(a, b, d);
+    else
+        out.quad(a, b, c, d);
+}
+/** Points along a polyline profile, each segment its own strip so every corner creases. */
+function creasedStrips(points) {
+    const strips = [];
+    for (let i = 0; i + 1 < points.length; i++) {
+        const [r0, y0] = points[i] ?? [0, 0];
+        const [r1, y1] = points[i + 1] ?? [0, 0];
+        const len = Math.hypot(r1 - r0, y1 - y0) || 1;
+        const nr = (y1 - y0) / len;
+        const ny = -(r1 - r0) / len;
+        strips.push([
+            { r: r0, y: y0, nr, ny },
+            { r: r1, y: y1, nr, ny },
+        ]);
+    }
+    return strips;
+}
+/** An arc of the circle centred (cr, cy), radius `radius`, from angle `a0` to `a1` in `steps`. */
+function arc(cr, cy, radius, a0, a1, steps) {
+    const points = [];
+    for (let s = 0; s <= steps; s++) {
+        const a = a0 + ((a1 - a0) * s) / steps;
+        const c = Math.cos(a);
+        const sn = Math.sin(a);
+        points.push({ r: Math.max(0, cr + radius * c), y: cy + radius * sn, nr: c, ny: sn });
+    }
+    return points;
+}
+/** A cylinder of `radius` and `length` along Y, centred, capped. */
+export function solidCylinder(radius, length, segments, smooth = false) {
+    return solidFrustum(radius, radius, length, segments, smooth);
+}
+/** A cone: base `radius` at −length/2, apex at +length/2. */
+export function solidCone(radius, length, segments, smooth = false) {
+    return solidFrustum(radius, 0, length, segments, smooth);
+}
+/** A frustum with explicit radii at its bottom (−length/2) and top (+length/2), capped. */
+export function solidFrustum(radiusBottom, radiusTop, length, segments, smooth = false) {
+    const h = length / 2;
+    return revolve(creasedStrips([
+        [0, -h],
+        [radiusBottom, -h],
+        [radiusTop, h],
+        [0, h],
+    ]), segments, smooth);
+}
+/** A hollow cylinder: outer `radius`, wall `thickness`, `length` along Y, centred. Four segments make a square frame. */
+export function solidTube(radius, thickness, length, segments, smooth = false) {
+    const h = length / 2;
+    const inner = Math.max(0, radius - thickness);
+    return revolve(creasedStrips([
+        [inner, -h],
+        [radius, -h],
+        [radius, h],
+        [inner, h],
+        [inner, -h],
+    ]), segments, smooth);
+}
+/** A sphere of `radius`: `segments` around, half as many from pole to pole. */
+export function solidSphere(radius, segments, smooth = false) {
+    const rings = Math.max(2, Math.floor(segments / 2));
+    return revolve([arc(0, 0, radius, -Math.PI / 2, Math.PI / 2, rings)], segments, smooth);
+}
+/** A dome toward +Y on a flat base at the origin. */
+export function solidHemisphere(radius, segments, smooth = false) {
+    const rings = Math.max(1, Math.floor(segments / 4));
+    const base = [
+        { r: 0, y: 0, nr: 0, ny: -1 },
+        { r: radius, y: 0, nr: 0, ny: -1 },
+    ];
+    return revolve([base, arc(0, 0, radius, 0, Math.PI / 2, rings)], segments, smooth);
+}
+/** A capsule: a cylinder of `length` (excluding the caps) with hemispherical ends, along Y. */
+export function solidCapsule(radius, length, segments, smooth = false) {
+    const rings = Math.max(1, Math.floor(segments / 4));
+    const h = length / 2;
+    return revolve([
+        arc(0, -h, radius, -Math.PI / 2, 0, rings),
+        [
+            { r: radius, y: -h, nr: 1, ny: 0 },
+            { r: radius, y: h, nr: 1, ny: 0 },
+        ],
+        arc(0, h, radius, 0, Math.PI / 2, rings),
+    ], segments, smooth);
+}
+/** A torus around +Y: ring radius `major`, tube radius `minor`, `segments` around and `sides` across. */
+export function solidTorus(major, minor, segments, sides, smooth = false) {
+    return revolve([arc(major, 0, minor, 0, 2 * Math.PI, Math.max(3, Math.floor(sides)))], segments, smooth);
+}
+/**
+ * A profile (`r, y` pairs, bottom to top) revolved around +Y. An end off the axis is closed with a
+ * flat cap, so any profile makes a solid. Every profile corner creases, faceted or smooth.
+ */
+export function solidLathe(profile, segments, smooth = false) {
+    const points = [];
+    for (let i = 0; i + 1 < profile.length; i += 2)
+        points.push([profile[i] ?? 0, profile[i + 1] ?? 0]);
+    const first = points[0];
+    const last = points[points.length - 1];
+    if (first && first[0] > 1e-12)
+        points.unshift([0, first[1]]);
+    if (last && last[0] > 1e-12)
+        points.push([0, last[1]]);
+    return revolve(creasedStrips(points), segments, smooth);
+}
+/**
+ * An icosahedron subdivided `level` times onto a sphere of `radius`. Faceted by default — every
+ * triangle its own vertices and face normal — or smooth, sharing vertices with radial normals.
+ */
+export function solidIcosphere(radius, level, smooth = false) {
+    const t = (1 + Math.sqrt(5)) / 2;
+    const verts = [
+        [-1, t, 0],
+        [1, t, 0],
+        [-1, -t, 0],
+        [1, -t, 0],
+        [0, -1, t],
+        [0, 1, t],
+        [0, -1, -t],
+        [0, 1, -t],
+        [t, 0, -1],
+        [t, 0, 1],
+        [-t, 0, -1],
+        [-t, 0, 1],
+    ].map(unit);
+    let faces = [
+        [0, 11, 5],
+        [0, 5, 1],
+        [0, 1, 7],
+        [0, 7, 10],
+        [0, 10, 11],
+        [1, 5, 9],
+        [5, 11, 4],
+        [11, 10, 2],
+        [10, 7, 6],
+        [7, 1, 8],
+        [3, 9, 4],
+        [3, 4, 2],
+        [3, 2, 6],
+        [3, 6, 8],
+        [3, 8, 9],
+        [4, 9, 5],
+        [2, 4, 11],
+        [6, 2, 10],
+        [8, 6, 7],
+        [9, 8, 1],
+    ];
+    for (let l = 0; l < Math.floor(level); l++) {
+        const cache = new Map();
+        const mid = (a, b) => {
+            const key = a < b ? `${a},${b}` : `${b},${a}`;
+            const hit = cache.get(key);
+            if (hit !== undefined)
+                return hit;
+            const va = verts[a] ?? [0, 0, 0];
+            const vb = verts[b] ?? [0, 0, 0];
+            verts.push(unit([
+                (va[0] ?? 0) + (vb[0] ?? 0),
+                (va[1] ?? 0) + (vb[1] ?? 0),
+                (va[2] ?? 0) + (vb[2] ?? 0),
+            ]));
+            cache.set(key, verts.length - 1);
+            return verts.length - 1;
+        };
+        const next = [];
+        for (const [a = 0, b = 0, c = 0] of faces) {
+            const ab = mid(a, b);
+            const bc = mid(b, c);
+            const ca = mid(c, a);
+            next.push([a, ab, ca], [b, bc, ab], [c, ca, bc], [ab, bc, ca]);
+        }
+        faces = next;
+    }
+    const out = new SolidWriter();
+    const uv = (p) => [
+        0.5 + Math.atan2(p[2] ?? 0, p[0] ?? 0) / (2 * Math.PI),
+        0.5 + Math.asin(Math.max(-1, Math.min(1, p[1] ?? 0))) / Math.PI,
+    ];
+    if (smooth) {
+        for (const p of verts) {
+            const [u, v] = uv(p);
+            out.vertex((p[0] ?? 0) * radius, (p[1] ?? 0) * radius, (p[2] ?? 0) * radius, p[0] ?? 0, p[1] ?? 0, p[2] ?? 0, u, v);
+        }
+        /* The table's faces run counter-clockwise seen from outside, as every face here does. */
+        for (const [a = 0, b = 0, c = 0] of faces)
+            out.triangle(a, b, c);
+        return out.finish();
+    }
+    for (const [a = 0, b = 0, c = 0] of faces) {
+        const pa = verts[a] ?? [0, 0, 0];
+        const pb = verts[b] ?? [0, 0, 0];
+        const pc = verts[c] ?? [0, 0, 0];
+        const n = unit([
+            ((pa[0] ?? 0) + (pb[0] ?? 0) + (pc[0] ?? 0)) / 3,
+            ((pa[1] ?? 0) + (pb[1] ?? 0) + (pc[1] ?? 0)) / 3,
+            ((pa[2] ?? 0) + (pb[2] ?? 0) + (pc[2] ?? 0)) / 3,
+        ]);
+        const base = out.vertexCount;
+        for (const p of [pa, pb, pc]) {
+            const [u, v] = uv(p);
+            out.vertex((p[0] ?? 0) * radius, (p[1] ?? 0) * radius, (p[2] ?? 0) * radius, n[0] ?? 0, n[1] ?? 0, n[2] ?? 0, u, v);
+        }
+        out.triangle(base, base + 1, base + 2);
+    }
+    return out.finish();
+}
+function unit(p) {
+    const len = Math.hypot(p[0] ?? 0, p[1] ?? 0, p[2] ?? 0) || 1;
+    return [(p[0] ?? 0) / len, (p[1] ?? 0) / len, (p[2] ?? 0) / len];
+}

package/dist/geometry/solidWriter.d.ts

@@ -0,0 +1,16 @@
+import type { Solid } from './solid.ts';
+export declare class SolidWriter {
+    private readonly positions;
+    private readonly normals;
+    private readonly uvs;
+    private readonly indices;
+    private count;
+    /** Add one vertex and return its index. The normal is taken as given; pass it unit length. */
+    vertex(px: number, py: number, pz: number, nx: number, ny: number, nz: number, u: number, v: number): number;
+    triangle(a: number, b: number, c: number): void;
+    /** Two triangles over a counter-clockwise quad `a b c d`. */
+    quad(a: number, b: number, c: number, d: number): void;
+    /** How many vertices so far, which is the index the next `vertex` returns. */
+    get vertexCount(): number;
+    finish(): Solid;
+}

package/dist/geometry/solidWriter.js

@@ -0,0 +1,42 @@
+/**
+ * The accumulator every solid primitive writes through: a vertex at a time, a triangle or a quad at
+ * a time, finished into a `Solid`.
+ *
+ * Internal to the geometry modules and not in the barrel — a caller building geometry of its own
+ * wants `MeshBuilder` or typed arrays, and this exists so the primitives share one place that
+ * decides how a vertex is laid out.
+ */
+import { GrowableF32, GrowableU32 } from './growable.js';
+export class SolidWriter {
+    positions = new GrowableF32();
+    normals = new GrowableF32();
+    uvs = new GrowableF32();
+    indices = new GrowableU32();
+    count = 0;
+    /** Add one vertex and return its index. The normal is taken as given; pass it unit length. */
+    vertex(px, py, pz, nx, ny, nz, u, v) {
+        this.positions.push(px, py, pz);
+        this.normals.push(nx, ny, nz);
+        this.uvs.push(u, v);
+        return this.count++;
+    }
+    triangle(a, b, c) {
+        this.indices.push(a, b, c);
+    }
+    /** Two triangles over a counter-clockwise quad `a b c d`. */
+    quad(a, b, c, d) {
+        this.indices.push(a, b, c, a, c, d);
+    }
+    /** How many vertices so far, which is the index the next `vertex` returns. */
+    get vertexCount() {
+        return this.count;
+    }
+    finish() {
+        return {
+            positions: this.positions.toTyped(),
+            normals: this.normals.toTyped(),
+            uvs: this.uvs.toTyped(),
+            indices: this.indices.toTyped(),
+        };
+    }
+}

package/dist/index.d.ts

@@ -123,6 +123,13 @@ export { GLOBAL_FIELD_BLEND, composeGlobalField, createGlobalField, sampleGlobal
 export type { FieldSource, GlobalField, GlobalFieldCascade, GlobalFieldInstance, } from './render/gi/globalField.ts';
 export { FIELD_FADE_SEC, LightField } from './render/driftLight/lightField.ts';
 export type { LightFieldOptions, LightFieldSource } from './render/driftLight/lightField.ts';
+export { DENSE_MAX_AXIS, DENSE_MAX_HEIGHT, bakeDenseField, } from './render/driftLight/denseField.ts';
+export type { DenseLightVolume } from './render/driftLight/denseField.ts';
+export { WorldLightField } from './render/driftLight/worldLightField.ts';
+export type { WorldLightFieldOptions } from './render/driftLight/worldLightField.ts';
+export { SURFACE_EFFECT_TEXELS, packSurfaceEffects } from './render/surfaceEffects.ts';
+export type { SurfaceLayerEffect } from './render/surfaceEffects.ts';
+export type { FieldLight } from './render/driftLight/bake.ts';
 export { GI_SCREEN_MARCH, SCREEN_TRACE_BIAS_M, screenRayOrigin, traceScreen, } from './render/gi/traceScreen.ts';
 export { FIELD_MARCH, coneRadiusAt, newFieldHit, traceField } from './render/gi/traceField.ts';
 export type { FieldHit, FieldMarch } from './render/gi/traceField.ts';
@@ -213,7 +220,9 @@ export { isWeakGpuFamily } from './render/gpuCapability.ts';
  */
 export { describeGpu } from './render/gpuCapability.ts';
 export type { GpuIdentity, DescribeGpuOptions } from './render/gpuCapability.ts';
-export { DEFAULT_POINT_LIGHT_VIEW_RANGE, createPointLightBuffer, selectPointLights, } from './render/pointLightSelection.ts';
+export { DEFAULT_POINT_LIGHT_VIEW_RANGE, createPointLightBuffer, selectGridLights, selectPointLights, } from './render/pointLightSelection.ts';
+export { LIGHT_GRID_MAX_CELLS, createLightGrid, gatherLights } from './render/lightGrid.ts';
+export type { LightGrid } from './render/lightGrid.ts';
 export type { PointLightBuffer, PointLightSource } from './render/pointLightSelection.ts';
 export { createFlame, flameFrequencyHz, updateFlame } from './render/flameLight.ts';
 export type { Flame, FlameOptions } from './render/flameLight.ts';
@@ -238,6 +247,14 @@ export { WaterRenderer } from './render/waterRenderer.ts';
 export type { WaterBody, WaterBounds, WaterSettings } from './render/waterRenderer.ts';
 export { MeshBuilder } from './geometry/meshBuilder.ts';
 export { concatMeshes, placeMesh } from './geometry/meshConcat.ts';
+export { emptySolid, mergeSolids, solidToMesh, solidVolume, transformSolid, } from './geometry/solid.ts';
+export type { Solid } from './geometry/solid.ts';
+export { solidBox, solidExtrude, solidPrism, solidQuad, solidRoundedBox, solidSweep, } from './geometry/solidFlat.ts';
+export { solidCapsule, solidCone, solidCylinder, solidFrustum, solidHemisphere, solidIcosphere, solidLathe, solidSphere, solidTorus, solidTube, } from './geometry/solidRound.ts';
+export { solidIntersect, solidSubtract, solidUnion } from './geometry/csg.ts';
+export { boxBooleanCells, solidBoxBoolean } from './geometry/boxCsg.ts';
+export type { BoxOperation } from './geometry/boxCsg.ts';
+export { smoothSolidNormals } from './geometry/solidNormals.ts';
 export { generateTangents } from './geometry/tangents.ts';
 export type { MeshBuildOptions } from './geometry/meshBuilder.ts';
 export { Spline, createSplineSample } from './geometry/spline.ts';
@@ -358,7 +375,9 @@ export type { FlockParams } from './render/flockRenderer.ts';
 export { buildTree } from './geometry/treeBuilder.ts';
 export type { TreeParams, TreeGeometry } from './geometry/treeBuilder.ts';
 export type { InstanceData } from './render/instancedMesh.ts';
-export type { MeshInstances } from './render/instances.ts';
+export type { InstancedOptions, MeshInstances } from './render/instances.ts';
+export { batchBoxVisible, cullInstances, instancesBox } from './render/instanceCull.ts';
+export type { BoxOccluder } from './render/instanceCull.ts';
 export type { WindProfile, WindState } from './render/wind.ts';
 export { cellBounds, cellCoord, cellCoordInRange, cellCoordsOf, cellIdFor, cellIdFrom, cellsInFrustum, cellsInRadius, createCellGrid, } from './world/cell.ts';
 export type { CellGrid } from './world/cell.ts';
@@ -367,3 +386,5 @@ export { cameraPositionFrom, cellPredictor, createCellStream, pumpCellStream, se
 export type { CellStore, CellStream, CellStreamOptions } from './world/cellStream.ts';
 export { createFrozenCells, freezeCell, frozenEntities, frozenFingerprintContribution, isCellFrozen, thawCell, } from './world/freeze.ts';
 export type { FreezableWorld, FrozenCell, FrozenCells } from './world/freeze.ts';
+export { HLOD_NONE, HlodSet, createHlodDraws, projectionScaleOf } from './world/hlod.ts';
+export type { HlodDraws, HlodOptions } from './world/hlod.ts';