@driftengine/assets 4.2.1 → 4.4.0

package/README.md

@@ -2,7 +2,7 @@
 
 Model readers for seven formats, and the streaming loader that uploads them.
 
-**Cost: 12.7 KB gzipped on top of core.** Measured by `scripts/size-gate.test.mjs`, which fails if it drifts more than
+**Cost: 15.8 KB gzipped on top of core.** Measured by `scripts/size-gate.test.mjs`, which fails if it drifts more than
 3% — the number is a fact about the build rather than a claim in a document.
 
 Part of [DriftEngine](../../README.md). See [`docs/ARCHITECTURE.md`](../../docs/ARCHITECTURE.md)

package/dist/bake/collapseHeap.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The simplifier's queue: candidate edge collapses, cheapest first.
+ *
+ * A binary min-heap in parallel typed arrays grown by doubling, because a scene's meshes queue
+ * millions of candidates and an object each would be most of the bake's memory. A candidate carries
+ * the version its vertex had when it was costed; the caller discards one whose vertex has moved on
+ * since, rather than the heap finding and removing it.
+ */
+export declare class CollapseHeap {
+    private costs;
+    private us;
+    private vs;
+    private versions;
+    size: number;
+    push(cost: number, u: number, v: number, version: number): void;
+    topCost(): number;
+    pop(): {
+        u: number;
+        v: number;
+        version: number;
+    };
+    private move;
+    private grow;
+}

package/dist/bake/collapseHeap.js

@@ -0,0 +1,80 @@
+/**
+ * The simplifier's queue: candidate edge collapses, cheapest first.
+ *
+ * A binary min-heap in parallel typed arrays grown by doubling, because a scene's meshes queue
+ * millions of candidates and an object each would be most of the bake's memory. A candidate carries
+ * the version its vertex had when it was costed; the caller discards one whose vertex has moved on
+ * since, rather than the heap finding and removing it.
+ */
+export class CollapseHeap {
+    costs = new Float64Array(1024);
+    us = new Int32Array(1024);
+    vs = new Int32Array(1024);
+    versions = new Uint32Array(1024);
+    size = 0;
+    push(cost, u, v, version) {
+        if (this.size === this.costs.length)
+            this.grow();
+        let i = this.size++;
+        while (i > 0) {
+            const parent = (i - 1) >> 1;
+            if (this.costs[parent] <= cost)
+                break;
+            this.move(parent, i);
+            i = parent;
+        }
+        this.costs[i] = cost;
+        this.us[i] = u;
+        this.vs[i] = v;
+        this.versions[i] = version;
+    }
+    topCost() {
+        return this.costs[0];
+    }
+    pop() {
+        const top = { u: this.us[0], v: this.vs[0], version: this.versions[0] };
+        const last = --this.size;
+        const cost = this.costs[last];
+        const u = this.us[last];
+        const v = this.vs[last];
+        const version = this.versions[last];
+        let i = 0;
+        for (;;) {
+            const left = i * 2 + 1;
+            if (left >= last)
+                break;
+            const right = left + 1;
+            const child = right < last && this.costs[right] < this.costs[left] ? right : left;
+            if (this.costs[child] >= cost)
+                break;
+            this.move(child, i);
+            i = child;
+        }
+        this.costs[i] = cost;
+        this.us[i] = u;
+        this.vs[i] = v;
+        this.versions[i] = version;
+        return top;
+    }
+    move(from, to) {
+        this.costs[to] = this.costs[from];
+        this.us[to] = this.us[from];
+        this.vs[to] = this.vs[from];
+        this.versions[to] = this.versions[from];
+    }
+    grow() {
+        const size = this.costs.length * 2;
+        const costs = new Float64Array(size);
+        costs.set(this.costs);
+        const us = new Int32Array(size);
+        us.set(this.us);
+        const vs = new Int32Array(size);
+        vs.set(this.vs);
+        const versions = new Uint32Array(size);
+        versions.set(this.versions);
+        this.costs = costs;
+        this.us = us;
+        this.vs = vs;
+        this.versions = versions;
+    }
+}

package/dist/bake/collapseMeasures.d.ts

@@ -0,0 +1,31 @@
+/**
+ * What an edge collapse is judged by: how far it moves the surface, and how far it slides a texture.
+ *
+ * The surface is measured by quadrics (Garland and Heckbert): each vertex carries the planes of the
+ * faces around it as ten sums, weighted by area, and a point's cost is its squared distance from
+ * them. The texture is measured against the uv each vertex was painted with, read back off the
+ * triangles a collapse leaves. Positions are a flat `Float64Array` of xyz and uvs a flat
+ * `Float32Array` of uv, both indexed by vertex.
+ */
+/** A key for the undirected edge `a`–`b` among `v` vertices. */
+export declare function edgeKey(a: number, b: number, v: number): number;
+/** The unit normal of a triangle into `out`, returning twice its area, or 0 for none. */
+export declare function triangleNormal(p: Float64Array, a: number, b: number, c: number, out: number[]): number;
+/** Adds the plane `ax + by + cz + d = 0`, weighted by `w`, to vertex `vert`'s quadric. */
+export declare function addPlane(q: Float64Array, vert: number, a: number, b: number, c: number, d: number, w: number): void;
+/** Vertex `vert`'s quadric at the point `x, y, z`: its planes' weighted squared distance from it. */
+export declare function quadricAt(q: Float64Array, vert: number, x: number, y: number, z: number): number;
+/** Every face's plane on its three corners, weighted by its area, and each corner's area summed. */
+export declare function addFacePlanes(p: Float64Array, faces: Uint32Array, quadric: Float64Array, area: Float64Array): void;
+/**
+ * A plane standing on every open edge, perpendicular to its face, so a border holds its line.
+ * `edges` counts the faces on each edge, keyed by `edgeKey`.
+ */
+export declare function addBorderPlanes(p: Float64Array, faces: Uint32Array, edges: ReadonlyMap<number, number>, quadric: Float64Array): void;
+/** A triangle's signed area in uv. */
+export declare function uvArea(uvs: Float32Array, a: number, b: number, c: number): number;
+/**
+ * How far `sample`'s own uv is from what the triangles in `corners` interpolate where it lies: the
+ * triangle it projects into, or the nearest one where it projects into none.
+ */
+export declare function uvMiss(p: Float64Array, uvs: Float32Array, corners: readonly number[], sample: number): number;

package/dist/bake/collapseMeasures.js

@@ -0,0 +1,183 @@
+/**
+ * What an edge collapse is judged by: how far it moves the surface, and how far it slides a texture.
+ *
+ * The surface is measured by quadrics (Garland and Heckbert): each vertex carries the planes of the
+ * faces around it as ten sums, weighted by area, and a point's cost is its squared distance from
+ * them. The texture is measured against the uv each vertex was painted with, read back off the
+ * triangles a collapse leaves. Positions are a flat `Float64Array` of xyz and uvs a flat
+ * `Float32Array` of uv, both indexed by vertex.
+ */
+/** How much a border's own planes weigh against the faces', per unit of edge length squared. */
+const BORDER_WEIGHT = 4;
+/**
+ * How far past a triangle's edge a sample may lie, in barycentric units, and still be measured
+ * against it: a vertex on a border that curves, which the straightened border no longer quite
+ * reaches. Further out, the surface the sample was painted on has gone from under it.
+ */
+const NEAR_EDGE = 0.05;
+/** A key for the undirected edge `a`–`b` among `v` vertices. */
+export function edgeKey(a, b, v) {
+    return a < b ? a * v + b : b * v + a;
+}
+/** The unit normal of a triangle into `out`, returning twice its area, or 0 for none. */
+export function triangleNormal(p, a, b, c, out) {
+    const ux = p[b * 3] - p[a * 3];
+    const uy = p[b * 3 + 1] - p[a * 3 + 1];
+    const uz = p[b * 3 + 2] - p[a * 3 + 2];
+    const vx = p[c * 3] - p[a * 3];
+    const vy = p[c * 3 + 1] - p[a * 3 + 1];
+    const vz = p[c * 3 + 2] - p[a * 3 + 2];
+    const nx = uy * vz - uz * vy;
+    const ny = uz * vx - ux * vz;
+    const nz = ux * vy - uy * vx;
+    const length = Math.hypot(nx, ny, nz);
+    if (length <= 1e-30)
+        return 0;
+    out[0] = nx / length;
+    out[1] = ny / length;
+    out[2] = nz / length;
+    return length;
+}
+/** Adds the plane `ax + by + cz + d = 0`, weighted by `w`, to vertex `vert`'s quadric. */
+export function addPlane(q, vert, a, b, c, d, w) {
+    const at = vert * 10;
+    q[at] = q[at] + w * a * a;
+    q[at + 1] = q[at + 1] + w * a * b;
+    q[at + 2] = q[at + 2] + w * a * c;
+    q[at + 3] = q[at + 3] + w * a * d;
+    q[at + 4] = q[at + 4] + w * b * b;
+    q[at + 5] = q[at + 5] + w * b * c;
+    q[at + 6] = q[at + 6] + w * b * d;
+    q[at + 7] = q[at + 7] + w * c * c;
+    q[at + 8] = q[at + 8] + w * c * d;
+    q[at + 9] = q[at + 9] + w * d * d;
+}
+/** Vertex `vert`'s quadric at the point `x, y, z`: its planes' weighted squared distance from it. */
+export function quadricAt(q, vert, x, y, z) {
+    const at = vert * 10;
+    return (q[at] * x * x +
+        2 * q[at + 1] * x * y +
+        2 * q[at + 2] * x * z +
+        2 * q[at + 3] * x +
+        q[at + 4] * y * y +
+        2 * q[at + 5] * y * z +
+        2 * q[at + 6] * y +
+        q[at + 7] * z * z +
+        2 * q[at + 8] * z +
+        q[at + 9]);
+}
+/** Every face's plane on its three corners, weighted by its area, and each corner's area summed. */
+export function addFacePlanes(p, faces, quadric, area) {
+    const f = faces.length / 3;
+    const n = [0, 0, 0];
+    for (let face = 0; face < f; face++) {
+        const a = faces[face * 3];
+        const b = faces[face * 3 + 1];
+        const c = faces[face * 3 + 2];
+        const twice = triangleNormal(p, a, b, c, n);
+        if (twice <= 0)
+            continue;
+        const w = twice / 2;
+        const d = -(n[0] * p[a * 3] + n[1] * p[a * 3 + 1] + n[2] * p[a * 3 + 2]);
+        for (const vert of [a, b, c]) {
+            addPlane(quadric, vert, n[0], n[1], n[2], d, w);
+            area[vert] = area[vert] + w;
+        }
+    }
+}
+/**
+ * A plane standing on every open edge, perpendicular to its face, so a border holds its line.
+ * `edges` counts the faces on each edge, keyed by `edgeKey`.
+ */
+export function addBorderPlanes(p, faces, edges, quadric) {
+    const v = p.length / 3;
+    const f = faces.length / 3;
+    const n = [0, 0, 0];
+    for (let face = 0; face < f; face++) {
+        const a0 = faces[face * 3];
+        const b0 = faces[face * 3 + 1];
+        const c0 = faces[face * 3 + 2];
+        if (triangleNormal(p, a0, b0, c0, n) <= 0)
+            continue;
+        for (let k = 0; k < 3; k++) {
+            const a = faces[face * 3 + k];
+            const b = faces[face * 3 + ((k + 1) % 3)];
+            if (edges.get(edgeKey(a, b, v)) !== 1)
+                continue;
+            const ex = p[b * 3] - p[a * 3];
+            const ey = p[b * 3 + 1] - p[a * 3 + 1];
+            const ez = p[b * 3 + 2] - p[a * 3 + 2];
+            let px = ey * n[2] - ez * n[1];
+            let py = ez * n[0] - ex * n[2];
+            let pz = ex * n[1] - ey * n[0];
+            const length = Math.hypot(px, py, pz);
+            if (length <= 0)
+                continue;
+            px /= length;
+            py /= length;
+            pz /= length;
+            const d = -(px * p[a * 3] + py * p[a * 3 + 1] + pz * p[a * 3 + 2]);
+            const w = BORDER_WEIGHT * (ex * ex + ey * ey + ez * ez);
+            addPlane(quadric, a, px, py, pz, d, w);
+            addPlane(quadric, b, px, py, pz, d, w);
+        }
+    }
+}
+/** A triangle's signed area in uv. */
+export function uvArea(uvs, a, b, c) {
+    const ux = uvs[b * 2] - uvs[a * 2];
+    const uy = uvs[b * 2 + 1] - uvs[a * 2 + 1];
+    const vx = uvs[c * 2] - uvs[a * 2];
+    const vy = uvs[c * 2 + 1] - uvs[a * 2 + 1];
+    return (ux * vy - uy * vx) / 2;
+}
+/**
+ * How far `sample`'s own uv is from what the triangles in `corners` interpolate where it lies: the
+ * triangle it projects into, or the nearest one where it projects into none.
+ */
+export function uvMiss(p, uvs, corners, sample) {
+    let inside = Infinity;
+    let nearest = Infinity;
+    let nearestMiss = Infinity;
+    const px = p[sample * 3];
+    const py = p[sample * 3 + 1];
+    const pz = p[sample * 3 + 2];
+    for (let t = 0; t < corners.length; t += 3) {
+        const a = corners[t];
+        const b = corners[t + 1];
+        const c = corners[t + 2];
+        const e0x = p[b * 3] - p[a * 3];
+        const e0y = p[b * 3 + 1] - p[a * 3 + 1];
+        const e0z = p[b * 3 + 2] - p[a * 3 + 2];
+        const e1x = p[c * 3] - p[a * 3];
+        const e1y = p[c * 3 + 1] - p[a * 3 + 1];
+        const e1z = p[c * 3 + 2] - p[a * 3 + 2];
+        const qx = px - p[a * 3];
+        const qy = py - p[a * 3 + 1];
+        const qz = pz - p[a * 3 + 2];
+        const d00 = e0x * e0x + e0y * e0y + e0z * e0z;
+        const d01 = e0x * e1x + e0y * e1y + e0z * e1z;
+        const d11 = e1x * e1x + e1y * e1y + e1z * e1z;
+        const d20 = qx * e0x + qy * e0y + qz * e0z;
+        const d21 = qx * e1x + qy * e1y + qz * e1z;
+        const denominator = d00 * d11 - d01 * d01;
+        if (denominator <= 1e-30)
+            continue;
+        const beta = (d11 * d20 - d01 * d21) / denominator;
+        const gamma = (d00 * d21 - d01 * d20) / denominator;
+        const alpha = 1 - beta - gamma;
+        const outside = Math.max(0, -alpha, -beta, -gamma);
+        const u = alpha * uvs[a * 2] + beta * uvs[b * 2] + gamma * uvs[c * 2];
+        const w = alpha * uvs[a * 2 + 1] + beta * uvs[b * 2 + 1] + gamma * uvs[c * 2 + 1];
+        const miss = Math.hypot(u - uvs[sample * 2], w - uvs[sample * 2 + 1]);
+        if (outside < 1e-6)
+            inside = Math.min(inside, miss);
+        else if (outside < nearest) {
+            nearest = outside;
+            nearestMiss = miss;
+        }
+    }
+    if (inside !== Infinity)
+        return inside;
+    return nearest < NEAR_EDGE ? nearestMiss : Infinity;
+}

package/dist/bake/sceneField.d.ts

@@ -0,0 +1,6 @@
+import type { DrftSdfvEntry, MeshData } from '@driftengine/drft';
+/**
+ * The field of every mesh `include` admits, merged, at `voxelM` spacing, as the file's
+ * whole-geometry entry. Null when nothing is admitted.
+ */
+export declare function bakeSceneField(meshes: readonly MeshData[], voxelM: number, include: (index: number) => boolean): DrftSdfvEntry | null;

package/dist/bake/sceneField.js

@@ -0,0 +1,48 @@
+/**
+ * One distance field over a file's static geometry, for tracing indirect light through a scene.
+ *
+ * **One field for the scene rather than one per mesh, because a bought scene is shaped against the
+ * per-mesh bake.** Its walls come as a few meshes spanning the whole of it, so a field sized to
+ * each mesh's longest side is metre-wide voxels on exactly the walls the light bounces off, and
+ * four hundred of them add more than the model's own geometry. Merged, the same scene is one grid
+ * at a voxel size the caller chooses: 25 cm resolves a column, and a courtyard is three megabytes.
+ *
+ * **What goes in is the caller's to say**, for the reason `addDistanceField` gives: light is traced
+ * against what it is safe to be blocked by. Walls and floors, not foliage, not cloth, not the copies
+ * of a candle drawn ten thousand times. What it gives up is movement: a merged field is static, so
+ * anything that moves wants a field of its own.
+ */
+import { concatMeshes } from '@driftengine/core';
+import { SDFV_WHOLE_FILE } from '@driftengine/drft';
+import { bakeObjectSdf } from './sdf.js';
+/**
+ * The field of every mesh `include` admits, merged, at `voxelM` spacing, as the file's
+ * whole-geometry entry. Null when nothing is admitted.
+ */
+export function bakeSceneField(meshes, voxelM, include) {
+    const chosen = [];
+    for (let index = 0; index < meshes.length; index++) {
+        if (include(index))
+            chosen.push(meshes[index]);
+    }
+    if (chosen.length === 0)
+        return null;
+    const merged = concatMeshes(chosen);
+    const positions = merged.positions;
+    let longest = 0;
+    for (let axis = 0; axis < 3; axis++) {
+        let lo = Number.POSITIVE_INFINITY;
+        let hi = Number.NEGATIVE_INFINITY;
+        for (let at = axis; at < positions.length; at += 3) {
+            const value = positions[at];
+            if (value < lo)
+                lo = value;
+            if (value > hi)
+                hi = value;
+        }
+        longest = Math.max(longest, hi - lo);
+    }
+    const resolution = Math.max(2, Math.ceil(longest / voxelM) + 1);
+    const baked = bakeObjectSdf(merged, resolution);
+    return { mesh: SDFV_WHOLE_FILE, dims: baked.dims, bounds: baked.bounds, field: baked.field };
+}

package/dist/bake/sdf.d.ts

@@ -30,11 +30,11 @@ export interface ObjectSdf {
  * has a gradient whose length varies with direction, which is the one property a sphere trace
  * depends on, and the failure is a march that overshoots along the coarse axis.
  *
- * **The sign comes from crossing parity, not from the winding.** A face normal, an
- * angle-weighted pseudonormal and a generalised winding number all flip when a mesh is exported
- * with its triangles the other way round, and importers disagree about that constantly — so a
- * model from the wrong tool would come back solid where it is empty. Counting how many times a
- * ray along `x` crosses the surface does not care which way a triangle faces.
+ * **The sign comes from how many surfaces separate a point from open air, not from the winding.**
+ * A face normal, an angle-weighted pseudonormal and a generalised winding number all flip when a
+ * mesh is exported with its triangles the other way round, and importers disagree about that
+ * constantly. A walk over the grid from its own faces does not care which way a triangle faces, and
+ * unlike crossing parity along one axis it does not need the mesh to be closed. See `surfaceDepth.ts`.
  *
  * **The magnitude comes from exact point-to-triangle distance, not from voxelisation.** Marking
  * the cells a triangle passes through and flooding outward loses any wall thinner than a cell,

package/dist/bake/sdf.js

@@ -1,4 +1,5 @@
 /** A signed distance field per object, baked offline, for tracing light through a world. */
+import { surfaceDepth } from './surfaceDepth.js';
 /**
  * Voxels of clearance around the mesh, on every axis.
  *
@@ -28,11 +29,11 @@ const UNREACHED = 1e30;
  * has a gradient whose length varies with direction, which is the one property a sphere trace
  * depends on, and the failure is a march that overshoots along the coarse axis.
  *
- * **The sign comes from crossing parity, not from the winding.** A face normal, an
- * angle-weighted pseudonormal and a generalised winding number all flip when a mesh is exported
- * with its triangles the other way round, and importers disagree about that constantly — so a
- * model from the wrong tool would come back solid where it is empty. Counting how many times a
- * ray along `x` crosses the surface does not care which way a triangle faces.
+ * **The sign comes from how many surfaces separate a point from open air, not from the winding.**
+ * A face normal, an angle-weighted pseudonormal and a generalised winding number all flip when a
+ * mesh is exported with its triangles the other way round, and importers disagree about that
+ * constantly. A walk over the grid from its own faces does not care which way a triangle faces, and
+ * unlike crossing parity along one axis it does not need the mesh to be closed. See `surfaceDepth.ts`.
  *
  * **The magnitude comes from exact point-to-triangle distance, not from voxelisation.** Marking
  * the cells a triangle passes through and flooding outward loses any wall thinner than a cell,
@@ -93,8 +94,6 @@ export function bakeObjectSdf(mesh, resolution) {
     const field = new Float32Array(count).fill(UNREACHED);
     /** The triangle each grid point's distance was measured to, and -1 where none has reached. */
     const closest = new Int32Array(count).fill(-1);
-    /** How many times the surface is crossed between grid point `i - 1` and `i` along `x`. */
-    const crossings = new Int32Array(count);
     const ox = origin[0];
     const oy = origin[1];
     const oz = origin[2];
@@ -132,37 +131,6 @@ export function bakeObjectSdf(mesh, resolution) {
                 }
             }
         }
-        /*
-         * Where a ray along `x` through each grid column crosses this triangle. Recorded at the first
-         * grid point past the crossing, so a scan along `x` accumulating these counts knows, at every
-         * point, how many surfaces stand between it and the grid's `-x` face.
-         */
-        for (let k = clampIndex(Math.ceil((Math.min(az, bz, cz) - oz) / step), nz); k < nz; k++) {
-            const gz = oz + k * step;
-            if (gz > Math.max(az, bz, cz))
-                break;
-            for (let j = clampIndex(Math.ceil((Math.min(ay, by, cy) - oy) / step), ny); j < ny; j++) {
-                const gy = oy + j * step;
-                if (gy > Math.max(ay, by, cy))
-                    break;
-                const bary = barycentric2d(gy, gz, ay, az, by, bz, cy, cz);
-                if (bary === null)
-                    continue;
-                const x = bary[0] * ax + bary[1] * bx + bary[2] * cx;
-                const i = Math.ceil((x - ox) / step);
-                /*
-                 * **Unreachable while `PAD_VOXELS` is at least one, and kept because it is a constant.**
-                 * The grid reaches two voxels past the mesh on every axis, so no crossing can land past
-                 * the `+x` face; with no padding one could, and clamping it would mark the last grid point
-                 * as having one more surface behind it than it does — flipping the parity of a point that
-                 * is outside. A crossing before the `-x` face is clamped to zero, where it is true: the
-                 * grid's first point really does have that surface behind it.
-                 */
-                if (i >= nx)
-                    continue;
-                crossings[Math.max(0, i) + nx * (j + ny * k)]++;
-            }
-        }
     }
     /*
      * Carry the closest triangle outward and recompute against it, eight directions twice. Two
@@ -181,16 +149,15 @@ export function bakeObjectSdf(mesh, resolution) {
         if (field[index] >= UNREACHED)
             field[index] = reach;
     }
-    for (let k = 0; k < nz; k++) {
-        for (let j = 0; j < ny; j++) {
-            let total = 0;
-            const row = nx * (j + ny * k);
-            for (let i = 0; i < nx; i++) {
-                total += crossings[row + i];
-                if (total % 2 === 1)
-                    field[row + i] = -field[row + i];
-            }
-        }
+    /*
+     * **The sign is how many surfaces stand between a point and the open air**: odd is inside. A walk
+     * over the grid answers that for every point, where crossing parity along one axis answered it
+     * only for a closed solid and striped the air of anything built from sheets. See `surfaceDepth.ts`.
+     */
+    const depth = surfaceDepth(field, dims, step);
+    for (let index = 0; index < count; index++) {
+        if (depth[index] % 2 === 1)
+            field[index] = -field[index];
     }
     return { field, dims, bounds };
 }
@@ -264,53 +231,6 @@ const NEIGHBOURS = [
 function clampIndex(value, count) {
     return value < 0 ? 0 : value > count - 1 ? count - 1 : value;
 }
-/**
- * Where a point stands in a triangle projected onto one plane, or null if it stands outside.
- *
- * **The tie-break is what stops a shared edge being counted twice or not at all.** A grid column
- * passing exactly along the edge two triangles share is inside both or neither depending on the
- * sign of a zero, and either answer flips the parity of an entire row. Breaking the tie on the
- * coordinates themselves makes the choice consistent between the two triangles: whichever way it
- * goes, exactly one of them claims the column.
- */
-function barycentric2d(px, py, ax, ay, bx, by, cx, cy) {
-    const bxr = bx - px;
-    const byr = by - py;
-    const cxr = cx - px;
-    const cyr = cy - py;
-    const axr = ax - px;
-    const ayr = ay - py;
-    const areaA = orientation(bxr, byr, cxr, cyr);
-    if (areaA.sign === 0)
-        return null;
-    const areaB = orientation(cxr, cyr, axr, ayr);
-    if (areaB.sign !== areaA.sign)
-        return null;
-    const areaC = orientation(axr, ayr, bxr, byr);
-    if (areaC.sign !== areaA.sign)
-        return null;
-    const sum = areaA.area + areaB.area + areaC.area;
-    if (sum === 0)
-        return null;
-    return [areaA.area / sum, areaB.area / sum, areaC.area / sum];
-}
-/** Twice the signed area of a triangle with the origin, with zero broken deterministically. */
-function orientation(x1, y1, x2, y2) {
-    const area = y1 * x2 - x1 * y2;
-    if (area > 0)
-        return { sign: 1, area };
-    if (area < 0)
-        return { sign: -1, area };
-    if (y2 > y1)
-        return { sign: 1, area };
-    if (y2 < y1)
-        return { sign: -1, area };
-    if (x1 > x2)
-        return { sign: 1, area };
-    if (x1 < x2)
-        return { sign: -1, area };
-    return { sign: 0, area };
-}
 /**
  * The distance from a point to the nearest point of a triangle.
  *

package/dist/bake/simplify.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A textured mesh brought down to the triangles its shape needs, at bake time, within a distance.
+ *
+ * **A bought scene is modelled for a renderer that is not in a hurry.** A courtyard measured here
+ * holds two million triangles of curtain, five million of ivy leaf and fifteen hundred a candle: at
+ * 4K a triangle of that cloth covers two pixels, and a GPU shades whole 2 × 2 quads, so most of the
+ * work is shading pixels nobody sees, in every shadow pass and every probe face as well as the frame.
+ *
+ * **Quadric error, half-edge collapses, and a hard bound.** Each vertex carries the planes of the
+ * faces around it, and a collapse is costed by the mean squared distance the moving vertex's planes
+ * are from where it lands, so a flat stretch goes first and a fold holds (Garland and Heckbert). The
+ * vertex moves onto a neighbour rather than to an optimal point, so every vertex that is left is one
+ * the author placed, with the normal, uv, colour and tangent they gave it: nothing is interpolated,
+ * and a texture stays where it was painted. Nothing collapses once the cheapest collapse would move
+ * the surface further than `maxError`.
+ *
+ * **What is held.** A vertex that shares its place with another is on a uv seam or a hard edge, and
+ * moving either copy opens the seam, so both stay. An open border simplifies only along itself,
+ * costed by planes standing on its edges, so a leaf keeps its outline to the same bound. A collapse
+ * that turns a face more than about seventy degrees, folds the texture over, stretches it more than
+ * half again, or joins two vertices whose normals part by more than twenty-five degrees is refused,
+ * and so is one after which a vertex taken in, by it or any collapse before, no longer finds its own
+ * uv on the surface that is left (`collapseMeasures.ts` measures both). A mesh with joints or morph
+ * targets comes back as it went in: a vertex there is a promise to a rig.
+ *
+ * **What it gives up** is a better placed vertex at the same count, which a full-edge collapse to
+ * the quadric's minimum would find, at the price of interpolating every attribute. What would make
+ * it wrong is a model whose detail is in its geometry rather than its maps at the scale of the bound.
+ */
+import type { MeshData } from '@driftengine/drft';
+export interface SimplifyOptions {
+    /** The furthest the surface may move, in the mesh's units: metres, for a baked scene. */
+    readonly maxError: number;
+    /**
+     * The furthest a texture may slide under the surface, in uv units: a texel of a 1,024 map by
+     * default. Checked at every vertex a collapse has removed, so it cannot accumulate.
+     */
+    readonly maxUvError?: number;
+    /** Stop once this share of the triangles is left, whatever the error. 0 by default. */
+    readonly minRatio?: number;
+}
+export declare function simplifyMesh(mesh: MeshData, options: SimplifyOptions): MeshData;