3draft 26.11.5001 → 26.11.11032

package/dist/instances.js

@@ -0,0 +1,41 @@
+// Prototypes and instances. A PROTOTYPE is a list of meshes of the same thing in decreasing detail (level of detail:
+// lods[0] is the finest), all of unit size and centred on the origin, with material SLOTS in `Face.mat` ('core', 'halo'...).
+// An INSTANCE is the prototype placed with a position, a size (one number, or one per slot) and its own slot -> palette
+// map, so a scene file stores the shape once and one short record per star. The detail used on screen follows the size
+// the thing has in pixels, so a far star costs a few faces and a near one a few dozen.
+/** A copy of the prototype mesh, scaled, moved and given its materials. Slots must not share vertices when scaled apart. */
+export const instantiate = (proto, p) => {
+    const slotOf = [];
+    for (const f of proto.faces)
+        for (const i of f.v)
+            slotOf[i] ??= f.mat ?? '';
+    const size = (slot) => (typeof p.scale === 'number' ? p.scale : (p.scale[slot] ?? p.scale['*'] ?? 1));
+    const positions = proto.positions.map((q, i) => {
+        const k = size(slotOf[i] ?? '');
+        let [x, y, z] = [q[0] * k, q[1] * k, q[2] * k];
+        if (p.rot) {
+            const [a, b] = p.rot;
+            [y, z] = [y * Math.cos(a) - z * Math.sin(a), y * Math.sin(a) + z * Math.cos(a)];
+            [x, z] = [x * Math.cos(b) + z * Math.sin(b), -x * Math.sin(b) + z * Math.cos(b)];
+        }
+        return [x + p.at[0], y + p.at[1], z + p.at[2]];
+    });
+    const faces = proto.faces.map((f) => {
+        const out = { v: f.v };
+        const mat = f.mat === undefined ? undefined : (p.mats?.[f.mat] ?? f.mat);
+        if (mat !== undefined)
+            out.mat = mat;
+        const color = p.color ?? f.color;
+        if (color !== undefined)
+            out.color = color;
+        return out;
+    });
+    return { positions, faces };
+};
+/** Which level of detail to draw for something that is `px` pixels across (its radius); `limits` are the pixel sizes where the next finer level starts. */
+export const lodLevel = (px, levels, limits = [60, 22, 8, 3, 1]) => {
+    let level = 0;
+    while (level < levels - 1 && level < limits.length && px < limits[level])
+        level++;
+    return level;
+};

package/dist/kernel.js

@@ -3,6 +3,7 @@
 // then every pick is one call that walks all triangles. Same answers as pick() in pick.ts.
 import { dot, norm, plus, times } from './vec.js';
 import { faceNormal } from './mesh.js';
+import { triangulate } from './triangulate.js';
 import { ray } from './camera.js';
 import { KERNEL_BYTES } from './kernel-bytes.js';
 const POS = 64; // vertices start here, 24 bytes each (f64 x y z)
@@ -38,14 +39,14 @@ export const initKernel = async () => {
             f64[i * 3 + 1] = p[1];
             f64[i * 3 + 2] = p[2];
         }
-        // faces are fanned into triangles (v0, vj, vj+1), each remembering its face number
+        // faces are cut into triangles (a fan, or ear clipping for a concave one), each remembering its face number
         const i32 = new Int32Array(memory.buffer, triBase, nt * 4);
         let at = 0;
         mesh.faces.forEach((f, face) => {
-            for (let j = 1; j < f.v.length - 1; j++) {
-                i32[at] = f.v[0];
-                i32[at + 1] = f.v[j];
-                i32[at + 2] = f.v[j + 1];
+            for (const [a, b, c] of triangulate(f.v.map((k) => mesh.positions[k]))) {
+                i32[at] = f.v[a];
+                i32[at + 1] = f.v[b];
+                i32[at + 2] = f.v[c];
                 i32[at + 3] = face;
                 at += 4;
             }

package/dist/lathe.d.ts

@@ -0,0 +1,13 @@
+import type { Mesh, Vec3 } from './types.js';
+export interface LatheFrame {
+    /** A point of the axis. */
+    origin: Vec3;
+    /** The axis direction, the direction of r = 1 in the plane, and the plane's normal (right × up = normal). */
+    right: Vec3;
+    up: Vec3;
+    normal: Vec3;
+}
+export declare const lathe: (contour: [number, number][], frame: LatheFrame, segments?: number, { mat, color }?: {
+    mat?: string;
+    color?: string;
+}) => Mesh;

package/dist/lathe.js

@@ -0,0 +1,87 @@
+// The lathe: a contour drawn on a plane is turned round an axis into a solid. Pure geometry, one closed mesh.
+// The axis is a line in the plane (for the app: the bottom line of the face the contour was drawn on); the contour is a list of
+// [u, r] points: u along the axis, r the distance from it (0 = on the axis). Both ends are closed: an end off the axis gets a flat disc,
+// an end on the axis is a point (a tip).
+import { add, scale as mul, dot } from './vec.js';
+export const lathe = (contour, frame, segments = 7, { mat, color = '#c8c8c8' } = {}) => {
+    if (!Number.isInteger(segments) || segments < 3)
+        throw new Error('a lathe needs 3 or more segments');
+    const span = Math.max(...contour.map(([, r]) => Math.abs(r)), 1e-9);
+    const eps = span * 1e-6;
+    // the same point twice in a row is one point
+    const pts = [];
+    for (const q of contour) {
+        const last = pts[pts.length - 1];
+        if (!last || Math.hypot(q[0] - last[0], q[1] - last[1]) > eps)
+            pts.push([q[0], q[1]]);
+    }
+    if (pts.length < 2)
+        throw new Error('the contour needs 2 different points');
+    if (pts.some(([, r]) => r < -eps))
+        throw new Error('the contour must stay on one side of the axis (r >= 0)');
+    const on = pts.map(([, r]) => r <= eps);
+    // which way is the inside: the sign of the area between the contour and the axis
+    const loop = [...pts, [pts[pts.length - 1][0], 0], [pts[0][0], 0]];
+    let area = 0;
+    for (let i = 0; i < loop.length; i++) {
+        const a = loop[i];
+        const b = loop[(i + 1) % loop.length];
+        area += a[0] * b[1] - b[0] * a[1];
+    }
+    if (Math.abs(area) < eps * span)
+        throw new Error('the contour and the axis enclose nothing');
+    const sgn = area > 0 ? 1 : -1;
+    const ang = (j) => (2 * Math.PI * j) / segments;
+    const radial = (t) => add(mul(frame.up, Math.cos(t)), mul(frame.normal, Math.sin(t)));
+    const positions = [];
+    const ring = pts.map(([u, r], i) => {
+        if (on[i]) {
+            positions.push(add(frame.origin, mul(frame.right, u)));
+            return [positions.length - 1];
+        }
+        return Array.from({ length: segments }, (_, j) => {
+            positions.push(add(add(frame.origin, mul(frame.right, u)), mul(radial(ang(j)), r)));
+            return positions.length - 1;
+        });
+    });
+    const faces = [];
+    const put = (v, want) => {
+        // wound so that the face looks the way it should (its Newell normal agrees with `want`)
+        const n = [0, 0, 0];
+        for (let k = 0; k < v.length; k++) {
+            const a = positions[v[k]];
+            const b = positions[v[(k + 1) % v.length]];
+            n[0] += (a[1] - b[1]) * (a[2] + b[2]);
+            n[1] += (a[2] - b[2]) * (a[0] + b[0]);
+            n[2] += (a[0] - b[0]) * (a[1] + b[1]);
+        }
+        faces.push({ v: dot(n, want) < 0 ? [...v].reverse() : v, color, ...(mat ? { mat } : {}) });
+    };
+    for (let i = 0; i + 1 < pts.length; i++) {
+        if (on[i] && on[i + 1])
+            continue; // a piece of the axis itself: no surface
+        const du = pts[i + 1][0] - pts[i][0];
+        const dr = pts[i + 1][1] - pts[i][1];
+        const n2 = [sgn * dr, -sgn * du]; // outward, in the plane of the contour
+        for (let j = 0; j < segments; j++) {
+            const want = add(mul(frame.right, n2[0]), mul(radial(ang(j + 0.5)), n2[1]));
+            const a = ring[i];
+            const b = ring[i + 1];
+            const j2 = (j + 1) % segments;
+            if (on[i])
+                put([a[0], b[j], b[j2]], want);
+            else if (on[i + 1])
+                put([a[j], a[j2], b[0]], want);
+            else
+                put([a[j], a[j2], b[j2], b[j]], want);
+        }
+    }
+    // the two ends: a disc where the contour does not end on the axis
+    const first = pts[0];
+    const last = pts[pts.length - 1];
+    if (!on[0])
+        put(ring[0], mul(frame.right, sgn * first[1]));
+    if (!on[pts.length - 1])
+        put(ring[pts.length - 1], mul(frame.right, -sgn * last[1]));
+    return { positions, faces };
+};

package/dist/material.d.ts

@@ -12,6 +12,8 @@ export interface Material {
     emit?: number;
     /** 0..1: soft, skin-like light. The light wraps round the form and a warm, scattered band shows where light turns to shade. */
     soft?: number;
+    /** A screen: a page shown on every four-cornered face of this material (the viewer puts an iframe over the picture, warped to the face). The renderers ignore it. */
+    url?: string;
 }
 export type Palette = Record<string, Material>;
 /** What a face is made of, all numbers filled in. */

package/dist/pick.js

@@ -3,6 +3,7 @@
 // the painter-sorted drawing is not.
 import { cross, dot, norm, plus, minus, times, scale } from './vec.js';
 import { faceNormal } from './mesh.js';
+import { triangulate } from './triangulate.js';
 import { ray } from './camera.js';
 const EPS = 1e-9;
 // Moller-Trumbore ray/triangle test. Distance along the ray, or null.
@@ -41,8 +42,8 @@ export const pick = (mesh, cam, x, y, { cull = true } = {}) => {
         const front = dot(outward, dir) < 0;
         if (cull && !front)
             return;
-        for (let j = 1; j < pts.length - 1; j++) {
-            const t = hitTriangle(origin, dir, pts[0], pts[j], pts[j + 1]);
+        for (const [a, b, c] of triangulate(pts)) {
+            const t = hitTriangle(origin, dir, pts[a], pts[b], pts[c]);
             if (t !== null && (!best || t < best.distance)) {
                 best = {
                     face: i,

package/dist/saw.d.ts

@@ -0,0 +1,29 @@
+import type { Mesh, Vec3 } from './types.js';
+/** A plane: a point on it and the unit normal. `front` is the side the normal points to. */
+export interface CutPlane {
+    point: Vec3;
+    n: Vec3;
+}
+export interface Sawn {
+    /** Closed pieces on the normal's side of the plane. */
+    front: Mesh[];
+    /** Closed pieces on the other side. */
+    back: Mesh[];
+}
+/**
+ * The plane a drawn line gives: it contains the line and stands square on the face the line was drawn on
+ * (`faceNormal`), so it runs straight into the material and out beyond the ends of the line.
+ */
+export declare const planeThroughLine: (a: Vec3, b: Vec3, faceNormal: Vec3) => CutPlane;
+/** The plane through three points. Throws when they lie on one line. */
+export declare const planeThroughTriangle: (a: Vec3, b: Vec3, c: Vec3) => CutPlane;
+/**
+ * Saw `mesh` along `plane`. `mat` / `color` is the material of the two new faces (the cut surface).
+ * Throws when the mesh is not a closed solid, or when the plane does not go through it.
+ */
+export declare const saw: (mesh: Mesh, plane: CutPlane, opts?: {
+    color?: string;
+    mat?: string;
+}) => Sawn;
+/** Where the plane meets the faces of the mesh: line segments for the preview of a cut. */
+export declare const sectionSegments: (mesh: Mesh, plane: CutPlane) => [Vec3, Vec3][];

package/dist/saw.js

@@ -0,0 +1,121 @@
+// The saw: one plane cuts a closed solid into closed solids, like a board on the bench.
+// The cut is a half-space (a huge box with one face on the plane) run through the boolean, so both sides come out
+// closed, every face stays planar, and the new face lies exactly in the saw plane (the "kerf" has no width).
+// A solid that the plane splits into several pieces (a U shape cut across its arms) comes out as several meshes.
+import { sub, cross, dot, len, norm, add, scale as mul } from './vec.js';
+import { box, bounds } from './mesh.js';
+import { subtract, intersect, splitParts } from './csg.js';
+import { validate } from './check.js';
+const MIN = 1e-9;
+/**
+ * The plane a drawn line gives: it contains the line and stands square on the face the line was drawn on
+ * (`faceNormal`), so it runs straight into the material and out beyond the ends of the line.
+ */
+export const planeThroughLine = (a, b, faceNormal) => {
+    const c = cross(sub(b, a), faceNormal);
+    if (len(c) < MIN * Math.max(1, len(sub(b, a))))
+        throw new Error('the line has no length, or it points along the face normal: it cannot give a plane');
+    return { point: a, n: norm(c) };
+};
+/** The plane through three points. Throws when they lie on one line. */
+export const planeThroughTriangle = (a, b, c) => {
+    const x = cross(sub(b, a), sub(c, a));
+    const scale = Math.max(len(sub(b, a)), len(sub(c, a)), MIN);
+    if (len(x) < 1e-9 * scale * scale)
+        throw new Error('the three points lie on one line: they do not give a plane');
+    return { point: a, n: norm(x) };
+};
+const frame = (n) => {
+    const helper = Math.abs(n[1]) < 0.9 ? [0, 1, 0] : [1, 0, 0];
+    const u = norm(cross(helper, n));
+    const v = cross(n, u);
+    return [u, v, n]; // right-handed: u x v = n
+};
+/**
+ * Saw `mesh` along `plane`. `mat` / `color` is the material of the two new faces (the cut surface).
+ * Throws when the mesh is not a closed solid, or when the plane does not go through it.
+ */
+export const saw = (mesh, plane, opts = {}) => {
+    // A model of several shells (a cube with a drawn-and-pulled-out V standing on it, a loose open surface): every closed shell is cut by
+    // itself, a shell the plane misses, or one that is not closed, goes whole to the side its middle is on.
+    const parts = splitParts(mesh);
+    if (parts.length > 1) {
+        const n = norm(plane.n);
+        const front = [];
+        const back = [];
+        let solids = 0;
+        let cut = 0;
+        for (const part of parts) {
+            const pv = validate(part);
+            if (pv.closed && !pv.inside_out) {
+                solids++;
+                try {
+                    const s = sawSolid(part, plane, opts);
+                    front.push(...s.front);
+                    back.push(...s.back);
+                    cut++;
+                    continue;
+                }
+                catch (err) {
+                    if (!/does not go through/.test(String(err.message)))
+                        throw err;
+                }
+            }
+            (dot(sub(bounds(part).center, plane.point), n) >= 0 ? front : back).push(part);
+        }
+        if (!solids)
+            throw new Error('saw: only a closed solid can be cut');
+        if (!cut)
+            throw new Error('the plane does not go through the object');
+        return { front, back };
+    }
+    return sawSolid(mesh, plane, opts);
+};
+const sawSolid = (mesh, plane, { color = '#c8c8c8', mat } = {}) => {
+    const v = validate(mesh);
+    if (!v.closed || v.inside_out)
+        throw new Error('saw: only a closed solid can be cut');
+    const n = norm(plane.n);
+    const { center, radius } = bounds(mesh);
+    const size = Math.max(radius, MIN) * 8;
+    const axes = frame(n);
+    // the half-space: a box whose bottom face lies in the plane and which reaches far past the solid on every side
+    const along = dot(sub(center, plane.point), n);
+    const origin = add(sub(center, mul(n, along)), mul(n, size / 2)); // centre of the box: over the foot of the solid's centre
+    const slab = box({ size: [size, size, size], at: origin, color, axes });
+    if (mat)
+        slab.faces.forEach((f) => (f.mat = mat));
+    const front = intersect(mesh, slab);
+    const back = subtract(mesh, slab);
+    if (!front.faces.length || !back.faces.length)
+        throw new Error('the plane does not go through the object');
+    return { front: splitParts(front), back: splitParts(back) };
+};
+/** Where the plane meets the faces of the mesh: line segments for the preview of a cut. */
+export const sectionSegments = (mesh, plane) => {
+    const n = norm(plane.n);
+    const out = [];
+    const eps = 1e-9 * Math.max(bounds(mesh).radius, 1);
+    const d = mesh.positions.map((p) => dot(sub(p, plane.point), n));
+    for (const f of mesh.faces) {
+        const hits = [];
+        f.v.forEach((i, k) => {
+            const j = f.v[(k + 1) % f.v.length];
+            const a = d[i];
+            const b = d[j];
+            if (Math.abs(a) <= eps && Math.abs(b) <= eps)
+                return; // an edge lying in the plane is the cut's boundary: shown from the other face
+            if ((a < -eps && b > eps) || (a > eps && b < -eps)) {
+                const t = a / (a - b);
+                hits.push(add(mesh.positions[i], mul(sub(mesh.positions[j], mesh.positions[i]), t)));
+            }
+            else if (Math.abs(a) <= eps)
+                hits.push(mesh.positions[i]);
+        });
+        // a convex face meets a plane in at most two points
+        const uniq = hits.filter((p, k) => hits.findIndex((q) => len(sub(p, q)) <= eps * 10) === k);
+        if (uniq.length === 2)
+            out.push([uniq[0], uniq[1]]);
+    }
+    return out;
+};

package/dist/svg.js

@@ -208,7 +208,7 @@ const panel = (mesh, view, o, x = 0, y = 0) => {
         return [
             `<polyline data-mark="${esc(m.name ?? 'mark')}" points="${pts.map((p) => `${num(p.x)},${num(p.y)}`).join(' ')}" ` +
                 `fill="none" stroke="${m.color ?? '#0b7285'}" stroke-width="${m.width ?? 2}" ` +
-                `stroke-linecap="round" stroke-linejoin="round"/>`,
+                `stroke-linecap="round" stroke-linejoin="round"${m.opacity !== undefined && m.opacity < 1 ? ` stroke-opacity="${m.opacity}"` : ''}/>`,
         ];
     }));
     return [

package/dist/text.d.ts

@@ -0,0 +1,25 @@
+import type { Mesh, Vec3 } from './types.js';
+type Pt = [number, number];
+/** The font: x 0..2, y 0..4 (the centre line of the strokes); accents rise above 4. */
+export declare const GLYPHS: Record<string, Pt[][]>;
+/** Grid units: the centre line is 4 high, the stroke 1: the letter is 5 high, so the stroke is 20 % of it. */
+export declare const STROKE = 0.2;
+export interface TextFrame {
+    /** The lower left corner of the first letter. */
+    origin: Vec3;
+    /** The reading direction, the up direction and the outward normal of the face (a right-handed frame: right × up = normal). */
+    right: Vec3;
+    up: Vec3;
+    normal: Vec3;
+    /** The letter height: also the face height it was taken from. */
+    height: number;
+}
+/** The frame of a face: it starts in the lower left corner (up = world up on the face; on a floor or ceiling: away from the viewer), and its height is the face's height. */
+export declare const faceFrame: (mesh: Mesh, face: number) => TextFrame;
+export interface TextOptions {
+    mat?: string;
+    color?: string;
+}
+/** The text as one mesh: every stroke a bar of stroke × stroke section standing out of the face by the stroke width. */
+export declare const textMesh: (text: string, frame: TextFrame, { mat, color }?: TextOptions) => Mesh;
+export {};

package/dist/text.js

@@ -0,0 +1,225 @@
+// Text as a model: a minimalist, blocky stroke font drawn on a 2 x 4 grid, every stroke a straight wooden wedge-simple bar.
+// The stroke is 20 % of the letter height (and so is the depth the letters stand out from the face).
+// Glyphs are data: lists of poly-lines; a poly-line of one point is a dot. Unknown characters are skipped, lower case is upper case.
+import { add, cross, dot, norm, scale, sub } from './vec.js';
+import { box, faceNormal, merge } from './mesh.js';
+import { health, union } from './csg.js';
+const G = (...lines) => lines;
+const O_ = [[0, 0], [0, 4], [2, 4], [2, 0], [0, 0]];
+/** The font: x 0..2, y 0..4 (the centre line of the strokes); accents rise above 4. */
+export const GLYPHS = {
+    A: G([[0, 0], [0, 4], [2, 4], [2, 0]], [[0, 2], [2, 2]]),
+    B: G(O_, [[0, 2], [2, 2]]),
+    C: G([[2, 4], [0, 4], [0, 0], [2, 0]]),
+    D: G([[0, 0], [0, 4], [1, 4], [2, 3], [2, 1], [1, 0], [0, 0]]),
+    E: G([[2, 4], [0, 4], [0, 0], [2, 0]], [[0, 2], [1.5, 2]]),
+    F: G([[2, 4], [0, 4], [0, 0]], [[0, 2], [1.5, 2]]),
+    G: G([[2, 4], [0, 4], [0, 0], [2, 0], [2, 2], [1, 2]]),
+    H: G([[0, 0], [0, 4]], [[2, 0], [2, 4]], [[0, 2], [2, 2]]),
+    I: G([[0, 4], [2, 4]], [[1, 4], [1, 0]], [[0, 0], [2, 0]]),
+    J: G([[2, 4], [2, 0], [0, 0], [0, 1]]),
+    K: G([[0, 0], [0, 4]], [[2, 4], [0, 2], [2, 0]]),
+    L: G([[0, 4], [0, 0], [2, 0]]),
+    M: G([[0, 0], [0, 4], [1, 2], [2, 4], [2, 0]]),
+    N: G([[0, 0], [0, 4], [2, 0], [2, 4]]),
+    O: G(O_),
+    P: G([[0, 0], [0, 4], [2, 4], [2, 2], [0, 2]]),
+    Q: G(O_, [[1, 1], [2, 0]]),
+    R: G([[0, 0], [0, 4], [2, 4], [2, 2], [0, 2]], [[1, 2], [2, 0]]),
+    S: G([[2, 4], [0, 4], [0, 2], [2, 2], [2, 0], [0, 0]]),
+    T: G([[0, 4], [2, 4]], [[1, 4], [1, 0]]),
+    U: G([[0, 4], [0, 0], [2, 0], [2, 4]]),
+    V: G([[0, 4], [1, 0], [2, 4]]),
+    W: G([[0, 4], [0.5, 0], [1, 2], [1.5, 0], [2, 4]]),
+    X: G([[0, 4], [2, 0]], [[0, 0], [2, 4]]),
+    Y: G([[0, 4], [1, 2], [2, 4]], [[1, 2], [1, 0]]),
+    Z: G([[0, 4], [2, 4], [0, 0], [2, 0]]),
+    '0': G(O_, [[0, 0], [2, 4]]),
+    '1': G([[0, 3], [1, 4], [1, 0]]),
+    '2': G([[0, 4], [2, 4], [2, 2], [0, 2], [0, 0], [2, 0]]),
+    '3': G([[0, 4], [2, 4], [2, 0], [0, 0]], [[0, 2], [2, 2]]),
+    '4': G([[0, 4], [0, 2], [2, 2]], [[2, 4], [2, 0]]),
+    '5': G([[2, 4], [0, 4], [0, 2], [2, 2], [2, 0], [0, 0]]),
+    '6': G([[2, 4], [0, 4], [0, 0], [2, 0], [2, 2], [0, 2]]),
+    '7': G([[0, 4], [2, 4], [0, 0]]),
+    '8': G(O_, [[0, 2], [2, 2]]),
+    '9': G([[2, 2], [0, 2], [0, 4], [2, 4], [2, 0], [0, 0]]),
+    '.': G([[1, 0]]),
+    ',': G([[1, 0], [0.5, -1]]),
+    ':': G([[1, 0]], [[1, 2.5]]),
+    '!': G([[1, 4], [1, 1.5]], [[1, 0]]),
+    '?': G([[0, 4], [2, 4], [2, 2], [1, 2], [1, 1]], [[1, 0]]),
+    '-': G([[0, 2], [2, 2]]),
+    _: G([[0, 0], [2, 0]]),
+    '+': G([[0, 2], [2, 2]], [[1, 3], [1, 1]]),
+    '/': G([[0, 0], [2, 4]]),
+    "'": G([[1, 4], [1, 3]]),
+    ' ': [],
+};
+// Hungarian (and other) accents: a letter plus a mark above it
+const ACUTE = G([[0.7, 5.4], [1.3, 6.4]]);
+const DOUBLE = G([[0, 5.4], [0.6, 6.4]], [[1.4, 5.4], [2, 6.4]]);
+const DOTS = G([[0, 5.6]], [[2, 5.6]]);
+const ACCENTS = {
+    Á: ['A', ACUTE], É: ['E', ACUTE], Í: ['I', ACUTE], Ó: ['O', ACUTE], Ú: ['U', ACUTE],
+    Ö: ['O', DOTS], Ü: ['U', DOTS], Ő: ['O', DOUBLE], Ű: ['U', DOUBLE],
+};
+/** Grid units: the centre line is 4 high, the stroke 1: the letter is 5 high, so the stroke is 20 % of it. */
+export const STROKE = 0.2;
+const CELL_H = 5;
+const ADVANCE = 4; // 3 wide letter + 1 gap
+const SPACE = 3;
+/** The frame of a face: it starts in the lower left corner (up = world up on the face; on a floor or ceiling: away from the viewer), and its height is the face's height. */
+export const faceFrame = (mesh, face) => {
+    const f = mesh.faces[face];
+    const n = norm(faceNormal(f.v.map((i) => mesh.positions[i])));
+    let up = sub([0, 1, 0], scale(n, dot([0, 1, 0], n)));
+    if (Math.hypot(...up) < 1e-3)
+        up = sub([0, 0, -1], scale(n, dot([0, 0, -1], n)));
+    up = norm(up);
+    const right = norm(cross(up, n));
+    let lo = Infinity, hi = -Infinity, left = Infinity;
+    for (const i of f.v) {
+        const p = mesh.positions[i];
+        const u = dot(p, up);
+        lo = Math.min(lo, u);
+        hi = Math.max(hi, u);
+        left = Math.min(left, dot(p, right));
+    }
+    const p0 = mesh.positions[f.v[0]];
+    // the point of the face plane with the lowest up and the lowest right
+    const origin = add(add(scale(right, left), scale(up, lo)), scale(n, dot(p0, n)));
+    return { origin, right, up, normal: n, height: Math.max(1e-6, hi - lo) };
+};
+const strokesOf = (ch) => {
+    const up = ch.toUpperCase();
+    const acc = ACCENTS[up];
+    if (acc)
+        return [{ at: 0, lines: GLYPHS[acc[0]] }, { at: 0, lines: acc[1] }];
+    const g = GLYPHS[up];
+    return g ? [{ at: 0, lines: g }] : [];
+};
+/** Faces that lie in one plane and touch along an edge become one face (the boolean cuts the big sides into pieces; a letter wants plain sides). */
+const mergeFlat = (mesh) => {
+    const P = mesh.positions;
+    let faces = mesh.faces.map((f) => ({ ...f, n: norm(faceNormal(f.v.map((i) => P[i]))) }));
+    const tryMerge = (a, b) => {
+        if (a.mat !== b.mat || a.color !== b.color || dot(a.n, b.n) < 1 - 1e-9)
+            return null;
+        const bAt = new Map();
+        b.v.forEach((v, i) => bAt.set(`${v},${b.v[(i + 1) % b.v.length]}`, i));
+        let shared = 0;
+        let start = -1;
+        a.v.forEach((u, i) => {
+            const w = a.v[(i + 1) % a.v.length];
+            if (bAt.has(`${w},${u}`)) {
+                shared++;
+                start = i;
+            }
+        });
+        if (!shared)
+            return null;
+        // the shared edge u -> v of a (v -> u in b): a from v round to u, then b from u round to v
+        const u = a.v[start];
+        const v = a.v[(start + 1) % a.v.length];
+        const ai = (start + 1) % a.v.length;
+        const A = a.v.map((_, k) => a.v[(ai + k) % a.v.length]); // v ... u
+        const bi = bAt.get(`${v},${u}`) + 1; // u in b
+        const B = b.v.map((_, k) => b.v[(bi + k) % b.v.length]); // u ... v
+        const out = [...A, ...B.slice(1, -1)];
+        // spikes: a vertex between two copies of the same neighbour (several shared edges in a row)
+        for (let again = true; again && out.length > 2;) {
+            again = false;
+            for (let i = 0; i < out.length; i++) {
+                if (out[(i + out.length - 1) % out.length] === out[(i + 1) % out.length]) {
+                    out.splice(i, 1);
+                    out.splice(i % out.length, 1);
+                    again = true;
+                    break;
+                }
+            }
+        }
+        if (out.length !== a.v.length + b.v.length - 2 * shared || new Set(out).size !== out.length)
+            return null;
+        // the engine's faces are convex (picking and painting assume it): a merge that would bend a face is not made
+        for (let i = 0; i < out.length; i++) {
+            const p0 = P[out[i]];
+            const p1 = P[out[(i + 1) % out.length]];
+            const p2 = P[out[(i + 2) % out.length]];
+            if (dot(cross(sub(p1, p0), sub(p2, p1)), a.n) < -1e-9)
+                return null;
+        }
+        return out;
+    };
+    for (let again = true; again;) {
+        again = false;
+        outer: for (let i = 0; i < faces.length; i++) {
+            for (let j = i + 1; j < faces.length; j++) {
+                const m = tryMerge(faces[i], faces[j]);
+                if (!m)
+                    continue;
+                faces = faces.filter((_, k) => k !== j);
+                faces[i] = { ...faces[i], v: m };
+                again = true;
+                break outer;
+            }
+        }
+    }
+    return { positions: P, faces: faces.map(({ n: _n, ...f }) => f) };
+};
+/** The bars of one letter fused into plain closed solids (no bar showing through another); if the fusing fails, the loose bars. */
+const solid = (bars) => {
+    if (bars.length < 2)
+        return merge(...bars);
+    try {
+        let m = bars[0];
+        for (const b of bars.slice(1))
+            m = union(m, b);
+        const h = health(m);
+        if (h.allSolid && h.skippedFaces === 0)
+            return mergeFlat(m);
+    }
+    catch {
+        /* fall through */
+    }
+    return merge(...bars);
+};
+/** The text as one mesh: every stroke a bar of stroke × stroke section standing out of the face by the stroke width. */
+export const textMesh = (text, frame, { mat, color = '#c8c8c8' } = {}) => {
+    const s = frame.height / CELL_H; // world units per grid unit
+    const letters = [];
+    let x = 0;
+    const half = 0.5; // the outer edge of the letter starts half a stroke before the centre line
+    for (const ch of text) {
+        if (ch === ' ') {
+            x += SPACE;
+            continue;
+        }
+        const bars = [];
+        for (const part of strokesOf(ch)) {
+            for (const line of part.lines) {
+                const pts = line.length === 1 ? [line[0], line[0]] : line;
+                for (let i = 0; i + 1 < pts.length; i++) {
+                    const [ax, ay] = pts[i];
+                    const [bx, by] = pts[i + 1];
+                    const dx = bx - ax;
+                    const dy = by - ay;
+                    const len = Math.hypot(dx, dy);
+                    const dir = len ? add(scale(frame.right, dx / len), scale(frame.up, dy / len)) : frame.right;
+                    const ez = frame.normal;
+                    const ey = cross(ez, dir);
+                    const cx = x + half + (ax + bx) / 2;
+                    const cy = half + (ay + by) / 2;
+                    const at = add(add(add(frame.origin, scale(frame.right, cx * s)), scale(frame.up, cy * s)), scale(ez, (1 * s) / 2));
+                    const bar = box({ size: [(len + 1) * s, s, s], at, axes: [dir, ey, ez], color });
+                    if (mat)
+                        bar.faces.forEach((f) => (f.mat = mat));
+                    bars.push(bar);
+                }
+            }
+        }
+        letters.push(solid(bars));
+        x += ADVANCE;
+    }
+    return merge(...letters);
+};

package/dist/triangulate.d.ts

@@ -0,0 +1,4 @@
+import type { Vec3 } from './types.js';
+export type Tri = [number, number, number];
+/** Indices into `pts`, three per triangle, `pts.length - 2` triangles. */
+export declare const triangulate: (pts: Vec3[]) => Tri[];