@driftengine/core 4.4.2 → 4.6.0

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

@@ -71,6 +71,10 @@ export type { PassAttachmentOptions, PassTarget } from './render/passTarget.ts';
 export { generateMipChain, mipLevelCount, type MipPipelines, } from './render/backend/webgpu/surfaceTexturePass.ts';
 export { createPassAttachment } from './render/passTarget.ts';
 export { jitterClip } from './render/recon/jitter.ts';
+export { resolveGlass } from './render/glass.ts';
+export type { GlassOptions, ResolvedGlass } from './render/glass.ts';
+export { createMover } from './render/recon/mover.ts';
+export type { Mover } from './render/recon/mover.ts';
 export type { FrameResource } from './render/frame/index.ts';
 export type { OcclusionOptions } from './render/occlusion.ts';
 export { OcclusionBuffer } from './render/occlusion.ts';
@@ -119,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';
@@ -193,7 +204,7 @@ export type { PrefilterQuality } from './render/prefilterEnvMap.ts';
  * `ProbeBakeOptions`, which is the whole of the reasoning.
  */
 export type { ProbeBakeOptions } from './render/reflectionProbe.ts';
-export type { DirectionalShadowDepthLayers, OutputTransform, RenderQuality, RenderQualityOptions, ShadowFilterTaps, WaterReflectionFilterTaps, } from './render/renderQuality.ts';
+export type { DirectionalShadowDepthLayers, GlassShadows, OutputTransform, RenderQuality, RenderQualityOptions, ShadowFilterTaps, WaterReflectionFilterTaps, } from './render/renderQuality.ts';
 export { MAX_POINT_LIGHTS, SURFACE_TEXTURE_UNIT } from './render/lightBudget.ts';
 export { MAX_CLUSTERED_LIGHTS } from './render/clusteredLights.ts';
 export { SurfaceTexture } from './render/surfaceTexture.ts';
@@ -209,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';
@@ -234,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';
@@ -354,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';
@@ -363,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';

package/dist/index.js

@@ -86,6 +86,13 @@ export { createPassAttachment } from './render/passTarget.js';
  * resolve finds its geometry where the renderer's own verbs put theirs.
  */
 export { jitterClip } from './render/recon/jitter.js';
+/*
+ * Which object a draw is, for a reconstruction that has to find where it was last frame. See
+ * `RendererApi.drawMesh`.
+ */
+/* Glass: a pane that shows what is behind it, clear or frosted. See `TranslucentMeshOptions.glass`. */
+export { resolveGlass } from './render/glass.js';
+export { createMover } from './render/recon/mover.js';
 export { OcclusionBuffer } from './render/occlusion.js';
 /*
  * `Renderer` above stays exported and is not deprecated. `createRenderer` is the way to get
@@ -173,6 +180,9 @@ export { countSplatTiles, fillSplatTiles, splatPixelBox, splatTileGrid, splatTil
 export { GI_SOURCE_FIELD, GI_SOURCE_PROBES, GI_SOURCE_SCREEN, newIndirectResult, traceIndirect, } from './render/gi/chain.js';
 export { GLOBAL_FIELD_BLEND, composeGlobalField, createGlobalField, sampleGlobalField, } from './render/gi/globalField.js';
 export { FIELD_FADE_SEC, LightField } from './render/driftLight/lightField.js';
+export { DENSE_MAX_AXIS, DENSE_MAX_HEIGHT, bakeDenseField, } from './render/driftLight/denseField.js';
+export { WorldLightField } from './render/driftLight/worldLightField.js';
+export { SURFACE_EFFECT_TEXELS, packSurfaceEffects } from './render/surfaceEffects.js';
 export { GI_SCREEN_MARCH, SCREEN_TRACE_BIAS_M, screenRayOrigin, traceScreen, } from './render/gi/traceScreen.js';
 export { FIELD_MARCH, coneRadiusAt, newFieldHit, traceField } from './render/gi/traceField.js';
 export { PROBE_VISIBILITY_SHARPNESS, bakeProbeVisibility, createProbeVisibility, probeUpdateSchedule, probeVisibilityWeight, sampleProbeVolume, visibleProbes, } from './render/gi/probeVolume.js';
@@ -259,7 +269,8 @@ export { isWeakGpuFamily } from './render/gpuCapability.js';
  * which is the right time for a boot log and too late for a decision.
  */
 export { describeGpu } from './render/gpuCapability.js';
-export { DEFAULT_POINT_LIGHT_VIEW_RANGE, createPointLightBuffer, selectPointLights, } from './render/pointLightSelection.js';
+export { DEFAULT_POINT_LIGHT_VIEW_RANGE, createPointLightBuffer, selectGridLights, selectPointLights, } from './render/pointLightSelection.js';
+export { LIGHT_GRID_MAX_CELLS, createLightGrid, gatherLights } from './render/lightGrid.js';
 export { createFlame, flameFrequencyHz, updateFlame } from './render/flameLight.js';
 export { computeLightMatrix } from './render/lightMatrix.js';
 export { PlumeRenderer } from './render/plumeRenderer.js';
@@ -299,6 +310,12 @@ export { SMOKE_FRAG } from './render/shaders/smoke.js';
 export { WaterRenderer } from './render/waterRenderer.js';
 export { MeshBuilder } from './geometry/meshBuilder.js';
 export { concatMeshes, placeMesh } from './geometry/meshConcat.js';
+export { emptySolid, mergeSolids, solidToMesh, solidVolume, transformSolid, } from './geometry/solid.js';
+export { solidBox, solidExtrude, solidPrism, solidQuad, solidRoundedBox, solidSweep, } from './geometry/solidFlat.js';
+export { solidCapsule, solidCone, solidCylinder, solidFrustum, solidHemisphere, solidIcosphere, solidLathe, solidSphere, solidTorus, solidTube, } from './geometry/solidRound.js';
+export { solidIntersect, solidSubtract, solidUnion } from './geometry/csg.js';
+export { boxBooleanCells, solidBoxBoolean } from './geometry/boxCsg.js';
+export { smoothSolidNormals } from './geometry/solidNormals.js';
 /* A tangent frame, which every map in the material track reads. */
 export { generateTangents } from './geometry/tangents.js';
 export { Spline, createSplineSample } from './geometry/spline.js';
@@ -467,6 +484,7 @@ export { parseSdfFont } from './render/sdfFont.js';
 export { DEFAULT_SDF_TEXT_STYLE, SdfTextLayout } from './render/sdfTextLayout.js';
 export { WindStreakRenderer } from './render/windStreakRenderer.js';
 export { buildTree } from './geometry/treeBuilder.js';
+export { batchBoxVisible, cullInstances, instancesBox } from './render/instanceCull.js';
 /*
  * Large worlds: the cell grid that streams and freezes, and the origin that rendering rebases
  * against while the simulation never does. See `world/rebase.ts` for why that asymmetry is the
@@ -476,3 +494,4 @@ export { cellBounds, cellCoord, cellCoordInRange, cellCoordsOf, cellIdFor, cellI
 export { renderOrigin, toRenderSpace, toWorldSpace } from './world/rebase.js';
 export { cameraPositionFrom, cellPredictor, createCellStream, pumpCellStream, setCellStreamOrigin, } from './world/cellStream.js';
 export { createFrozenCells, freezeCell, frozenEntities, frozenFingerprintContribution, isCellFrozen, thawCell, } from './world/freeze.js';
+export { HLOD_NONE, HlodSet, createHlodDraws, projectionScaleOf } from './world/hlod.js';

package/dist/render/backend/api.d.ts

@@ -4,12 +4,13 @@ import type { ReadonlyMat4 } from 'gl-matrix';
 import type { MeshData } from '../mesh.ts';
 import type { ProbeBakeOptions } from '../reflectionProbe.ts';
 import type { Renderer, TranslucentMeshOptions } from './webgl2/renderer.ts';
-import type { MeshInstances } from '../instances.ts';
+import type { InstancedOptions, MeshInstances } from '../instances.ts';
 import type { SurfaceMaterial } from '../surfaceTexture.ts';
 import type { TextStyle } from '../textLayout.ts';
 import type { SdfFont } from '../sdfFont.ts';
 import type { SdfTextStyle } from '../sdfTextLayout.ts';
 import type { FrameTimer } from './timer.ts';
+import type { Mover } from '../recon/mover.ts';
 /**
  * Geometry on the device, as something a consumer holds and hands back.
  *
@@ -174,9 +175,23 @@ export interface MeshOptions {
 }
 export type RendererApi = Omit<{
     [K in keyof Renderer]: Renderer[K];
-}, 'gpuTimer' | 'createMesh' | 'createMeshIncremental' | 'updateMesh' | 'drawMesh' | 'disposeMesh' | 'drawTranslucentMesh' | 'drawLightVolume' | 'drawFilm' | 'createScatter' | 'drawScatter' | 'uploadScatter' | 'disposeScatter' | 'createInstanced' | 'uploadInstanced' | 'drawInstanced' | 'drawTranslucentInstanced' | 'disposeInstanced' | 'createWater' | 'drawWater' | 'disposeWater' | 'createPlumes' | 'drawPlumes' | 'disposePlumes' | 'setPlumeScale' | 'createCaustics' | 'drawCaustics' | 'disposeCaustics' | 'createParticles' | 'drawParticles' | 'disposeParticles' | 'createWindStreaks' | 'drawWindStreaks' | 'disposeWindStreaks' | 'createFlock' | 'drawFlock' | 'disposeFlock' | 'createBolts' | 'drawBolts' | 'disposeBolts' | 'createLines' | 'drawLines' | 'disposeLines' | 'createText' | 'setText' | 'setPlate' | 'drawText' | 'textWidth' | 'disposeText' | 'createSdfText' | 'setSdfText' | 'drawSdfText' | 'disposeSdfText' | 'createSurfaceTexture' | 'updateSurfaceTexture' | 'disposeSurfaceTexture' | 'setSurfaceTexture' | 'setMaterial'> & {
+}, 'gpuTimer' | 'createMesh' | 'createMeshIncremental' | 'updateMesh' | 'drawMesh' | 'disposeMesh' | 'drawTranslucentMesh' | 'drawLightVolume' | 'drawFilm' | 'createScatter' | 'drawScatter' | 'uploadScatter' | 'disposeScatter' | 'createInstanced' | 'uploadInstanced' | 'drawInstanced' | 'drawTranslucentInstanced' | 'disposeInstanced' | 'createWater' | 'drawWater' | 'disposeWater' | 'createPlumes' | 'drawPlumes' | 'disposePlumes' | 'setPlumeScale' | 'createCaustics' | 'drawCaustics' | 'disposeCaustics' | 'createParticles' | 'drawParticles' | 'disposeParticles' | 'createWindStreaks' | 'drawWindStreaks' | 'disposeWindStreaks' | 'createFlock' | 'drawFlock' | 'disposeFlock' | 'createBolts' | 'drawBolts' | 'disposeBolts' | 'createLines' | 'drawLines' | 'disposeLines' | 'createText' | 'setText' | 'setPlate' | 'drawText' | 'textWidth' | 'disposeText' | 'createSdfText' | 'setSdfText' | 'drawSdfText' | 'disposeSdfText' | 'createSurfaceTexture' | 'createSurfaceTextureArray' | 'updateSurfaceTexture' | 'disposeSurfaceTexture' | 'setSurfaceTexture' | 'setMaterial'> & {
     /** Upload a caller's image. See `SurfaceTextureHandle` for the boundary this guards. */
     createSurfaceTexture(source: TexImageSource, options?: Parameters<Renderer['createSurfaceTexture']>[1]): SurfaceTextureHandle;
+    /**
+     * Upload several images of one size as the layers of one array texture.
+     *
+     * The same handle a single image returns — every surface texture is an array, and a plain image
+     * is an array of one — so it goes wherever a texture goes: any map of `setMaterial`. A mesh picks
+     * its image per vertex with `MeshData.layers`, and every map of the material is read at that
+     * layer, so an albedo array and an emissive array built in one order pair image with glow by
+     * index. **A merged mesh wearing many images is then one draw and one material change.**
+     *
+     * Every image must be the same size: the device allocates one size for every layer, and the
+     * refusal names the first image that differs. A layer past the end reads the last one.
+     * `updateSurfaceTexture` refuses an array.
+     */
+    createSurfaceTextureArray(sources: readonly TexImageSource[], options?: Parameters<Renderer['createSurfaceTexture']>[1]): SurfaceTextureHandle;
     /**
      * Replace a texture's pixels, keeping the GPU object and its sampler state.
      *
@@ -323,7 +338,7 @@ export type RendererApi = Omit<{
      * would wear one expression. Both are refused where the variant is built rather than dropped
      * quietly.
      */
-    createInstanced(mesh: MeshHandle, capacity: number): InstancedHandle;
+    createInstanced(mesh: MeshHandle, capacity: number, options?: InstancedOptions): InstancedHandle;
     /**
      * Push placement and colour to the device. Only `data.count` instances are written.
      *
@@ -466,18 +481,23 @@ export type RendererApi = Omit<{
     /** Draw a handle this renderer made. Passing one from the other backend is a caller error. */
     drawMesh(mesh: MeshHandle, model: ReadonlyMat4, depthLayer?: number, tint?: Vec3 | null, 
     /**
-     * Where this mesh's surface was last frame, for a reconstruction's motion target.
-     *
-     * **Only a reconstruction reads it**, and only on WebGPU: it is what turns a moving object's
-     * stale history from a smear into a reprojection. A draw that says nothing gets the camera's
-     * motion, derived from the depth, which is exactly right for anything that did not move and
-     * wrong in proportion to how far a mover moved. Null and omitted mean the same thing.
-     *
-     * It is the *model* matrix this mesh was drawn with last frame, not a velocity: the pass
-     * transforms each vertex twice and lets the perspective divide do the rest, so a rotation and a
-     * scale are as correct as a translation.
+     * Where this mesh's surface was last frame, for a reconstruction's motion target: a `Mover`,
+     * or last frame's model matrix.
+     *
+     * **A `Mover` is the ordinary answer.** Make one per moving object with `createMover()` and pass
+     * it with every draw of that object; the renderer keeps last frame's model and, for a skinned
+     * draw, last frame's palette. A matrix still works exactly as it always has: the *model* matrix
+     * this mesh was drawn with last frame, not a velocity, so a rotation and a scale are as correct
+     * as a translation. Null and omitted mean the same thing: the camera's motion, derived from the
+     * depth, which is exactly right for anything that did not move and wrong in proportion to how
+     * far a mover moved.
+     *
+     * **Only a reconstruction reads it**, and only on WebGPU. A mover drawn twice in one frame is
+     * two objects wearing one identity: the second draw is warned about once and records no motion.
+     * Instanced batches and meshes rewritten with `updateMesh` need none — the batch and the mesh
+     * are their own identity.
      */
-    previousModel?: ReadonlyMat4 | null): void;
+    previousModel?: ReadonlyMat4 | Mover | null): void;
     /** Release the geometry behind a handle. */
     disposeMesh(mesh: MeshHandle): void;
     /**

package/dist/render/backend/drawFog.d.ts

@@ -0,0 +1,26 @@
+/**
+ * How a draw meets the medium between it and the eye: the value of the mesh shader's
+ * `uFogEnabled`, which both backends write from this one rule.
+ *
+ * **A surface recedes into the medium; light added to the frame fades in it.** A surface that
+ * covers what is behind it is mixed toward the medium's colour with distance, which is the haze
+ * standing in front of it. An additive draw covers nothing: what is behind it has already been
+ * fogged, and mixing the draw toward the medium's colour and then *adding* it puts that haze into
+ * the frame a second time. So a glow by day added the sky's grey in the shape of the glow, and
+ * added more of it the thicker the air — reported as solid grey cones under every street lamp on
+ * a hazy morning. Faded instead, added light loses what the medium scatters out of it and adds
+ * nothing of its own, which is how the same shader already treats the glow behind frosted glass.
+ *
+ * What fading gives up is the one thing mixing did for a glow: at great distance it disappears
+ * into the air instead of greying into it. That is what light in fog does. What would make it
+ * wrong is an additive draw standing for *lit air* rather than light — and that is what
+ * `drawLightVolume` is for, which is fogged by neither rule.
+ */
+/** Out of the medium entirely: `TranslucentMeshOptions.fog` set to false. */
+export declare const FOG_OFF = 0;
+/** Mixed toward the medium's colour with distance: every surface, and the pass's default. */
+export declare const FOG_RECEDE = 1;
+/** Scaled down by what the medium scatters and given none of its colour: added light. */
+export declare const FOG_FADE = 2;
+/** The medium rule for a draw that asked for fog or not, and adds its light or covers. */
+export declare function fogModeOf(fog: boolean, additive: boolean): number;