3draft 26.11.11010 → 26.11.11032

package/APP.md

@@ -218,3 +218,21 @@ Every console group hangs from the same top line; `view` is first, so it stays p
 `edges` (the E switch) works in the GPU views too: `render({ edges: true })` draws the face edges (`buildEdges` / `sceneEdges` in `src/gpu.ts`, each vertex pair once, cached per part, none above 300 000 faces) as 1-pixel `line-list` / `gl.LINES` after the solid faces, dark at 40% alpha, depth tested with a hair of nudge towards the eye so a line wins against the face it lies on.
 
 With the palette open (`body.pal`, desktop) the view, the top line and the console get narrower by the width of the panel (`--palR`) instead of staying behind it; on the phone layout the panel still covers the view.
+
+## Screen material
+
+A material with an `url` (the palette's url field; the built-in `monitor` has one) is a screen: on every four-cornered face made of it the page runs in an iframe. The iframe is a DOM layer over the picture (`#screens`), warped onto the face with a CSS `matrix3d` (a perspective map of the face's four corners, up is the world up, the face's own up when it lies flat). Limits: it is not part of the 3D picture (no depth against other objects, so something standing in front does not hide it, and no light), it does not show in a VR view, faces seen from behind or behind the eye are hidden, at most 6 screens at once, the pointer goes through it until you take control of it (below), and sites that forbid framing (X-Frame-Options, CSP) stay blank. Only http(s) addresses are taken. Faces with another number of corners are plain surfaces. **Control:** double-click a screen and the page gets the pointer and the keys; the camera stays where it is. A `network` module appears after `sys` in the console: `exit`, an on / off switch (off blanks that screen, the monitor stays dark) and the page address, a link that opens it in a new tab. A press outside the page, `exit` or Esc (when the focus is not inside the page) gives the control back to the 3D view.
+
+## Saving scenes
+
+The `scene` panel has one list for adding a scene: the examples, and under `saved here` what was saved in this browser. Choosing an entry loads it: with the `merge` switch on (the default, remembered) it is added next to what is there, with `merge` off the scene is cleared first and the loaded one stands alone (U twice brings the old one back: the load, then the clear). It holds for the examples and `file ↑` too. Below the list: a name box and **save** (stores the whole scene under that name in this browser's local storage; an empty name gets a dated one), **file ↓** (downloads it as `name.json`), **file ↑** (adds a scene from a `.json` file) and **✕** (forgets the saved scene whose name is in the box). A scene file is `{ format: "3draft-scene", version: 1, name, palette: [the materials its faces use], objects: [{ name, mesh, wire? }] }`, the same shape as an example scene. Materials the palette lacks come along (screens keep their url). Not saved: the camera, the point clouds and flying prisms; instanced objects (the stars) are saved as the meshes they have at that moment. Local storage is per browser and per address, and about 5 MB; for anything bigger use the file.
+
+**View in the scene file.** A scene is saved with its view: `view: { edges, light, glow, smooth, studio, cam }` (the switches and the camera). It is applied when the scene stands alone (`merge` off, or nothing was in the scene); a merged scene keeps the view you have. The edges start off.
+
+**`?ply=name`** opens the scene saved here under that name at once, alone, with its view, in zen. Without such a saved scene the page starts as usual.
+
+## Text
+Edit mode, a face selected (3), **T**: asks for the words and makes a new model out of them (`text-xxxx`), standing out of the face in the active material. The face gives the lower-left start corner, the reading direction (world up on the face; on a floor: away from the viewer) and the letter height. The font is `src/text.ts`: data, poly-lines on a 2 × 4 grid, every stroke a bar; stroke and depth are 20 % of the letter height. The model carries `text` and `textFrame` (saved in scenes), and T on a text model fixes the words in place. The engine exports `textMesh`, `faceFrame`, `GLYPHS`.
+
+## Lathe
+Edit mode, a face selected, **6**: the face's plane (its `faceFrame`) is the drawing board, its bottom line the axis. V puts contour points, Enter asks for the segments (>= 4, Enter on its own = 7) and `lathe(contour, frame, segments, { mat, color })` (`src/lathe.ts`) turns the `[u, r]` contour round the axis into one closed mesh with outward faces; a tip on the axis is a point, an end off it gets a disc. The result is a new model.

package/dist/index.d.ts

@@ -1,10 +1,14 @@
 export declare const name: "3draft";
-export declare const version = "26.11.11010";
+export declare const version = "26.11.11032";
 export type { Vec3, Face, Mesh, Axes, ViewName, ViewSpec, Fit, Camera, Hit, Mark } from './types.js';
 export { box, extrude, merge, rotate, bounds, faceNormal, faceCenter } from './mesh.js';
 export type { BoxOptions } from './mesh.js';
 export { validate } from './check.js';
 export { boolean, union, subtract, intersect, health, splitParts } from './csg.js';
+export { lathe } from './lathe.js';
+export type { LatheFrame } from './lathe.js';
+export { textMesh, faceFrame, GLYPHS, STROKE as TEXT_STROKE } from './text.js';
+export type { TextFrame, TextOptions } from './text.js';
 export { saw, planeThroughLine, planeThroughTriangle, sectionSegments } from './saw.js';
 export type { CutPlane, Sawn } from './saw.js';
 export type { BooleanOp, Health, Part } from './csg.js';

package/dist/index.js

@@ -4,10 +4,12 @@
 // a target cross that lies on the surface under the cursor. No textures, no
 // shading yet.
 export const name = '3draft';
-export const version = '26.11.11010';
+export const version = '26.11.11032';
 export { box, extrude, merge, rotate, bounds, faceNormal, faceCenter } from './mesh.js';
 export { validate } from './check.js';
 export { boolean, union, subtract, intersect, health, splitParts } from './csg.js';
+export { lathe } from './lathe.js';
+export { textMesh, faceFrame, GLYPHS, STROKE as TEXT_STROKE } from './text.js';
 export { saw, planeThroughLine, planeThroughTriangle, sectionSegments } from './saw.js';
 export { extrudeFace, moveVertices } from './edit.js';
 export { VIEW_ORDER, makeCamera, orbit, project, ray } from './camera.js';

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "3draft",
-  "version": "26.11.11010",
+  "version": "26.11.11032",
   "description": "Minimalist AI first 3D engine: palette-texture, WASM core, WebGPU/WebGL2 renderer.",
   "type": "module",
   "main": "./dist/index.js",