3draft 26.11.3001 → 26.11.4010

package/APP.md

@@ -10,7 +10,7 @@ It is one file, `app/index.html`, plus a dependency-free static server (`app/ser
 
 ## The view
 
-- **Starting view: WebGPU.** If WebGPU is unavailable, or the GPU device is lost, the app falls back to SVG by itself and says so in the footer (`G` or the `WebGPU` button switches by hand). SVG shows colour and transparency only; WebGPU also shows metal, roughness and emission.
+- **Starting view: WebGPU.** If WebGPU is unavailable, or the GPU device is lost, the app falls back to SVG by itself and says so in the footer (`G` or the `WebGPU` button switches by hand). SVG shows colour and transparency only; WebGPU also shows metal, roughness and emission. The **filmic look** (`C`) adds linear light, Fresnel and tone mapping, so highlights roll off softly and `lamp`-like materials glow; switch it off for the plain flat look.
 - **The drawing fills the stage.** On a desktop it covers the whole area; on a phone it is a little larger than the short side.
 - **Drag** rotates, **double click** resets the view, the arrow keys rotate too.
 - **The cross** follows the pointer and lies on the surface under it. The cursor is always a cross. On a phone, with no mouse, it aims at the middle.
@@ -24,19 +24,27 @@ It is one file, `app/index.html`, plus a dependency-free static server (`app/ser
 | `Space` | stop moving (all speeds to zero) |
 | `T` | fly to the object under the cross. Over nothing, or when too close or inside a model: out to the nearest object |
 | `/` | show only the object under the cross; again: the whole scene, and the camera flies back to where it was |
-| `M` | place a prism on the surface under the cross, or shoot one into empty space |
-| `V` | Spider bar: the first `V` remembers a surface point, the second joins the two with a thin prism. `V` over empty space forgets the first point |
+| `M` | place a prism on the surface under the cross, or shoot one into empty space. **In isolated mode (`/`) it fires a bullet** instead: a prism that starts at the camera point and flies along the ray through the cursor, so its long axis is always the view direction and you always see its back; if it hits the isolated object it sinks half its length and carves that part out (A − B, the cut is made of the selected material, `U` undoes it); if it misses it flies on to 4 times the camera-to-model distance and vanishes. Only the closed parts of the model are carved; open parts are ignored (see the health check below). A carve never leaves a crack: if the result would not be a closed solid it is retried with a hair's shift, and if that fails too the model stays as it was (the note "left as it was" shows). |
+| `Tab` | edit mode on the object under the cross / off (see below) |
+| `V` | Spider bar (in edit mode: draw a line): the first `V` remembers a surface point, the second joins the two with a thin prism (a quarter of the base of a placed one) made of the selected material. `V` over empty space forgets the first point |
 | `X`, `Delete` | delete the object under the cross |
 | `U`, `Backspace` | undo: placing, deleting, painting, booleans and moves, one step at a time |
 | `P` | show / hide the material palette |
+| `I` | pick material: the material of the face under the cross becomes the selected one |
 | `Shift` + press | paint the face under the cross with the selected material (palette must be on) |
 | `Shift` + double click | paint the whole object |
 | `O` | boolean (see below) |
 | `H` | move gizmo (see below) |
 | `E` | edges and points on / off (also the `Edges` button) |
+| `C` | filmic look on / off (also the `Filmic` button; on at the start, WebGPU view only) |
 | `G`, `L` | SVG / WebGPU, turn the light |
 | `?` | show / hide these shortcuts under the view (hidden at the start; also the `Keys` button) |
 
+## Clear and example models
+
+- **`Clear`** (footer) removes every object in the scene. It is one undo step: `U` brings them all back.
+- **`+ Example…`** (the drop-down in the footer) adds a ready-made model to the scene: the house (the Blender import, 45 objects), the Cessna, the stone bridge or the table. It is placed beside what is already there, on its +x side, and the view frames everything. One `U` removes the whole example again. Examples are normal objects after that: paint, move, boolean and delete them like any other.
+
 ## Moving an object: the gizmo (`H`)
 
 There is one gizmo at a time, and `H` cycles through three states:
@@ -47,6 +55,28 @@ There is one gizmo at a time, and `H` cycles through three states:
 
 Drag one of the arrows to slide the object along that axis; the arrow thickens under the pointer. While dragging only the picture changes; one write goes to the database when you let go, and one `U` takes the whole drag back.
 
+## Edit mode: drawing on a model (`Tab`)
+
+The idea: there is a base model, and you refine or extend it by drawing lines on it. Put the cross on an object and press `Tab`. A red bar at the top says which object is being edited. Its vertices show as small grey crosses.
+
+- **`V` draws a line.** The first `V` takes a point, the next `V` joins it to the new one, and the chain goes on from there. A point is either an existing vertex (the pointer **snaps** to vertices; a white cross shows which) or a new vertex put on the surface under the cross. On a face it splits the face into triangles, on an edge it goes into both faces, so the surface never cracks.
+- **Two points on one face cut it.** The line becomes a real edge of the mesh: the surface gets detail exactly where you drew.
+- **Points in the air extend the model.** With a line in progress, `V` over empty space puts the next point on the plane that faces the camera through the last point. So you can draw a new part out from the model, and lines that end on existing vertices are attached to it.
+- **`Enter` closes a loop into a face.** The shortest closed loop (up to 8 lines) through the last line becomes a face with the selected material, wound away from the middle of the object. A loop of 4 or more becomes triangles, so faces stay flat.
+- **Nothing moves by default** (and never while you draw with `V`). Moving is Blender-style, with a key per mode, and every drag is one `U` step:
+  - `1` **move points:** hover a vertex (white cross), drag it.
+  - `2` **move lines:** hover an edge or a line (white), drag it; both ends move.
+  - `3` **move faces:** hover a face (white outline), drag it; all its vertices move together and the face stays flat.
+  - The drag slides in the plane that faces the camera. A selected point, line or face (orange) also gets a gizmo: drag an arrow to move along one axis. Everything that uses the moved vertices follows: lines, faces and the base surface, so this is how you reshape the original model. A polygon that gets only some of its vertices moved turns into triangles.
+  - `V` goes back to drawing (and drops the selection); `Esc` does the same.
+- **`B` turns the spider bars into lines.** The prisms made with `V` in object mode (they are objects named `bar`) become lines on the edited object: each end snaps to a vertex that is close, or is put on the surface if it is near it, or stays a free point. The bars are removed (one `U` brings them back). So a plan sketched as bars can be worked on as a wire.
+- **`X`** removes the lines at the selected point or line (or the last line); the points stay. `U` undoes every step, one key press at a time.
+- **`Esc`** stops the line you are drawing; then it leaves a move mode back to drawing; then it leaves edit mode (so does `Tab`). The lines are only shown in edit mode.
+
+The lines live next to the mesh as `wire: [[a, b], ...]` (vertex pairs) in the object's document, so the AI sees them too. The geometry is in the engine (README part 1): `insertVertex`, `cutFace`, `moveVertex`, `moveVertexSet`, `fillLoop`, `addLine`, `findLoop`.
+
+Limits for now: a face made from a non-flat or non-convex loop is only as good as its triangle fan, there is no mirror yet, and the lines are not deformation weights (a surface does not bend around a moved vertex, it just follows the vertices that are in the mesh).
+
 ## Boolean operations (`O`)
 
 Press `O` over an object: it gets an orange box. Press `O` over another one (green box): a small question asks which operation to run.
@@ -61,13 +91,15 @@ Press `O` over an object: it gets an orange box. Press `O` over another one (gre
 
 The result is a new object named like `A-B` and it replaces both operands; `U` brings the two originals back and removes the result. `O` over empty space forgets a marked object.
 
-The math is the engine's `boolean(a, b, op)` (README, part 1). Both objects must be **closed solids with outward faces**. An open shell, such as a wall without thickness, is refused with the reason in the dialog. With messy data (coincident faces) the result can come out open; the engine's `validate` says so.
+The math is the engine's `boolean(a, b, op)` (README, part 1). Only closed parts are calculated: a part that is not a closed solid (a surface, a box without a bottom) is left out, and a union keeps it as it is. The status line under the picture is the **health check** of the object under the cross: `solid`, `N of M parts closed · K faces open`, or `no closed part`. Each object needs at least one **closed solid with outward faces**; with none, the reason shows in the dialog. With messy data (coincident faces) the result can come out open; the engine's `validate` says so.
 
 ## Materials (`P`)
 
 Twelve starting materials: plaster, sand, wood, dark wood, concrete, slate, grass, brick, steel, gold, glass, lamp. Pick one, then `Shift`+press to paint a face or `Shift`+double click for the whole object.
 
-For the selected material there are four sliders (`metal`, `rough`, `alpha`, `emit`) and a colour; `+ new` copies it as a new material. A painted face stores the material **name**, so editing a material changes every face made of it.
+**Pick material (`I`, or the `pick` button):** the eyedropper. `I` takes the material of the face under the cross. The `pick` button arms it, and the next click on a surface takes it (`Esc` cancels). The palette opens and that material is selected, so you can read its sliders or paint with it right away. A face that has only a colour selects the material with that colour, or starts a new material from it.
+
+For the selected material there are four sliders (`metal`, `rough`, `alpha`, `emit`, 0 to 5) and a colour; `+ new` copies it as a new material. A painted face stores the material **name**, so editing a material changes every face made of it.
 
 ## Isolating, travelling
 

package/README.md

@@ -43,7 +43,7 @@ gpu.render(table, orbit({ yaw: -0.6, pitch: 0.45 }), { size: 600 });
 ![table sheet](examples/out/table.sheet.svg)
 
 - **SVG** is the deterministic preview (the same calls give the same text). Every `<polygon>` has `data-face` and `data-depth`, every `<circle>` has `data-v`. `occlude: true` paints into a small depth buffer first and sends only the faces and points that are seen (on the 5000-face house: 2793 -> about 680 polygons, 802 KB -> 175 KB, same picture).
-- **WebGPU** draws the same scene through the same camera (`viewProjection` is tested to hit the same pixels as `project`), with one shader, one light, alpha-to-coverage transparency and instancing.
+- **WebGPU** draws the same scene through the same camera (`viewProjection` is tested to hit the same pixels as `project`), with one shader, one light, real alpha blending (see-through faces in a second pass, sorted far to near) and instancing.
 - Cameras: `front`, `side`, `top` (orthographic) and `persp`; `orbit({ yaw, pitch })` is a turntable; any `{ dir, up, ortho }` works.
 - Faces are painter-sorted with plane tests; interpenetrating solids can show artifacts, hidden edges are not drawn, back-face culling assumes closed CCW meshes.
 
@@ -55,16 +55,19 @@ The palette is data: `{ name: { color, metal, rough, alpha, emit } }`. A face po
 |---|---|---|
 | `metal` 0..1 | paint ... metal | reflects sky and ground, tinted; strong highlight |
 | `rough` 0..1 | mirror ... matte | widens the highlight, blurs the reflection |
-| `alpha` 1..0 | solid ... invisible | alpha-to-coverage, one pass, no sorting (SVG: `fill-opacity`, and a see-through face hides nothing) |
-| `emit` 0..1 | lit ... glowing | the colour shows unshaded |
+| `alpha` 1..0 | solid ... invisible | blended in a second pass, far to near (SVG: `fill-opacity`, and a see-through face hides nothing) |
+| `emit` 0..5 | lit ... glowing | up to 1 the colour fades to unshaded; above 1 (with `tonemap`) it is a light source, that many times brighter |
 
 Pass the palette to the renderers: `renderView(mesh, view, { palette })`, `gpu.render(mesh, view, { palette })` (a new object when an entry changes). SVG shows colour and alpha only.
 
+`gpu.render(mesh, view, { tonemap: true })` switches on a filmic look: lighting in linear colour, HDR light, Fresnel on the edges, ACES tone mapping, and `emit` that really glows above white (`tonemap: { exposure, emit }` to tune; off by default, so the plain look stays the same).
+
 ### Surfaces, picking, editing
 
 - `pick(mesh, camera, x, y)` casts a real ray: face, point, normal, distance. `ray` is the inverse of `project`; `crosshair` builds a cross lying on the surface; `standOn` returns a prism standing on a picked surface.
 - `validate(mesh)` returns text notes: closed shell, winding, planar and convex faces. `extrudeFace`, `moveVertices`, `extrude`, `rotate`, `merge`, `bounds` shape meshes.
-- `boolean(a, b, op)` (also `union`, `subtract`, `intersect`) is solid modelling on BSP trees: faces are split by planes, so the result stays convex and planar. Both operands must be closed with outward faces; an open shell (a wall without thickness) is refused with the reason. Face colours and materials are kept; cut faces take the colour of the cutting solid. The result is welded and T-junctions are repaired; on messy data (coincident faces) it can still come out open, so check `validate`.
+- `boolean(a, b, op)` (also `union`, `subtract`, `intersect`) is solid modelling on BSP trees: faces are split by planes, so the result stays convex and planar. Both operands must be closed with outward faces; an open shell (a wall without thickness) is refused with the reason. With `{ strict: false }` the parts that are not closed solids are left out of the calculation instead (a union keeps them as they are, a subtract keeps those of `a`); `health(mesh)` is the check behind it: the connected parts, which are closed, and how many faces a boolean can work with. Face colours and materials are kept; cut faces take the colour of the cutting solid. The result is welded and T-junctions are repaired. A solid stays a solid: a result that is not a closed, consistently wound solid (numerical trouble with coincident faces) is thrown away and the operation is repeated with the second operand nudged by a tiny amount; if no try is sound it throws and the caller keeps the original.
+- **Drawing on a mesh** (`wire.ts`): `insertVertex(mesh, face, point)` puts a vertex on a surface (inside a face it makes a triangle fan, on an edge it joins both faces), `cutFace(mesh, a, b)` cuts a face along a line between two of its vertices, `moveVertex(mesh, i, to)` moves one (polygons that use it become triangles, so faces stay planar), `fillLoop(mesh, loop)` closes a loop of vertices into a face, `addLine` and `findLoop` keep the wire (a list of vertex pairs). These are what the viewer's edit mode (`Tab`, see [APP.md](APP.md)) uses.
 - **HEXAW kernel.** The picking hot loop is also written in [HEXAW](https://github.com/Pengeszikra/hexaw) (`kernel/pick.hexaw`, 569 bytes of WebAssembly). `initKernel()` starts it; `kernel.pick` returns exactly what `pick` returns, 0.14 ms instead of 1.7 ms on 7200 faces. The module is embedded as base64 (`src/kernel-bytes.ts`), so the engine needs neither HEXAW nor a fetch at runtime. `npm run kernel` re-assembles it.
 
 ### TypeScript and `|>`

package/dist/csg.d.ts

@@ -1,10 +1,35 @@
 import type { Mesh } from './types.js';
 export type BooleanOp = 'union' | 'subtract' | 'intersect';
+/** One connected piece of a mesh (faces joined by shared edges). */
+export interface Part {
+    /** Indices into mesh.faces. */
+    faces: number[];
+    closed: boolean;
+    insideOut: boolean;
+    openEdges: number;
+}
+export interface Health {
+    parts: Part[];
+    /** Faces in closed, outward parts: the ones a boolean can work with. */
+    usableFaces: number;
+    /** Faces in open (or inside-out) parts: a boolean ignores them. */
+    skippedFaces: number;
+    /** true when at least one part is a closed solid. */
+    hasSolid: boolean;
+    /** true when every part is a closed solid. */
+    allSolid: boolean;
+}
+/** Splits a mesh into connected parts and says which of them are closed solids (the health check). */
+export declare const health: (mesh: Mesh) => Health;
 /**
  * Boolean of two closed solids (outward CCW faces): 'union', 'subtract' (a minus b) or 'intersect'.
- * Throws with a reason when an input is open or inside out.
+ * Throws with a reason when an input is open or inside out. With `strict: false` the parts that are not closed solids are
+ * left out of the calculation instead (see `health`): a union keeps them as they are, a subtract keeps those of `a`,
+ * an intersect drops them; it throws only when `a` has no closed part at all.
  */
-export declare const boolean: (a: Mesh, b: Mesh, op: BooleanOp) => Mesh;
+export declare const boolean: (a: Mesh, b: Mesh, op: BooleanOp, { strict }?: {
+    strict?: boolean;
+}) => Mesh;
 export declare const union: (a: Mesh, b: Mesh) => Mesh;
 export declare const subtract: (a: Mesh, b: Mesh) => Mesh;
 export declare const intersect: (a: Mesh, b: Mesh) => Mesh;

package/dist/csg.js

@@ -145,8 +145,8 @@ const toMesh = (polys, scale) => {
             v.pop();
         if (v.length < 3)
             return [];
-        const n = faceNormal(v.map((k) => positions[k]));
-        return len(n) < 1e-9 * scale * scale ? [] : [{ v, color: p.color, mat: p.mat }];
+        // slivers stay for now: their vertices still give the neighbours' edges something to join to (see below)
+        return [{ v, color: p.color, mat: p.mat }];
     });
     // T-junctions: a vertex lying on the edge of a neighbouring face gets inserted into that edge
     const used = new Set(faces.flatMap((f) => f.v));
@@ -167,8 +167,8 @@ const toMesh = (polys, scale) => {
                     continue;
                 const on = [];
                 for (const k of verts) {
-                    if (k === a || k === b)
-                        continue;
+                    if (k === a || k === b || f.v.includes(k))
+                        continue; // never twice in one face
                     const pk = positions[k];
                     const t = dot(sub(pk, pa), d) / (dl * dl);
                     if (t <= 0 || t >= 1)
@@ -183,6 +183,10 @@ const toMesh = (polys, scale) => {
             return { ...f, v: out };
         });
     }
+    // Now the slivers can go: a face with no area (its corners are in a line, the neighbours already have the extra vertices)
+    // closes up around it. Dropping one before the T-junctions are done would leave a hole (an open edge) behind.
+    const flat = 1e-9 * scale * scale;
+    faces = faces.filter((f) => len(faceNormal(f.v.map((k) => positions[k]))) >= flat);
     return { positions, faces };
 };
 const closedSolid = (name, m) => {
@@ -192,13 +196,100 @@ const closedSolid = (name, m) => {
     if (v.inside_out)
         throw new Error(`boolean needs outward faces: ${name} is inside out`);
 };
+const subMesh = (mesh, idx) => {
+    const map = new Map();
+    const positions = [];
+    const faces = idx.map((i) => {
+        const f = mesh.faces[i];
+        return { ...f, v: f.v.map((k) => (map.has(k) ? map.get(k) : (map.set(k, positions.length), positions.push(mesh.positions[k]), positions.length - 1))) };
+    });
+    return { ...mesh, positions, faces };
+};
+/** Splits a mesh into connected parts and says which of them are closed solids (the health check). */
+export const health = (mesh) => {
+    const n = mesh.faces.length;
+    const root = Array.from({ length: n }, (_, i) => i);
+    const find = (i) => (root[i] === i ? i : (root[i] = find(root[i])));
+    const seen = new Map();
+    mesh.faces.forEach((f, i) => f.v.forEach((v, k) => {
+        const w = f.v[(k + 1) % f.v.length];
+        const key = v < w ? `${v},${w}` : `${w},${v}`;
+        const j = seen.get(key);
+        if (j === undefined)
+            seen.set(key, i);
+        else
+            root[find(i)] = find(j);
+    }));
+    const groups = new Map();
+    for (let i = 0; i < n; i++)
+        groups.set(find(i), [...(groups.get(find(i)) ?? []), i]);
+    const parts = [...groups.values()].map((faces) => {
+        const v = validate(subMesh(mesh, faces));
+        return { faces, closed: v.closed, insideOut: v.inside_out, openEdges: v.openEdges };
+    });
+    const usable = parts.filter((p) => p.closed && !p.insideOut);
+    const usableFaces = usable.reduce((t, p) => t + p.faces.length, 0);
+    return { parts, usableFaces, skippedFaces: n - usableFaces, hasSolid: usable.length > 0, allSolid: usable.length === parts.length && parts.length > 0 };
+};
+const append = (base, extra) => {
+    const o = base.positions.length;
+    return { ...base, positions: [...base.positions, ...extra.positions], faces: [...base.faces, ...extra.faces.map((f) => ({ ...f, v: f.v.map((k) => k + o) }))] };
+};
 /**
  * Boolean of two closed solids (outward CCW faces): 'union', 'subtract' (a minus b) or 'intersect'.
- * Throws with a reason when an input is open or inside out.
+ * Throws with a reason when an input is open or inside out. With `strict: false` the parts that are not closed solids are
+ * left out of the calculation instead (see `health`): a union keeps them as they are, a subtract keeps those of `a`,
+ * an intersect drops them; it throws only when `a` has no closed part at all.
  */
-export const boolean = (a, b, op) => {
-    closedSolid('a', a);
-    closedSolid('b', b);
+export const boolean = (a, b, op, { strict = true } = {}) => {
+    if (strict) {
+        closedSolid('a', a);
+        closedSolid('b', b);
+        return run(a, b, op);
+    }
+    const ha = health(a);
+    const hb = health(b);
+    if (!ha.hasSolid)
+        throw new Error('boolean: the model has no closed part (nothing to calculate with)');
+    if (!hb.hasSolid)
+        throw new Error('boolean: the second model has no closed part');
+    const pick = (m, h, closed) => subMesh(m, h.parts.filter((p) => (p.closed && !p.insideOut) === closed).flatMap((p) => p.faces).sort((x, y) => x - y));
+    let out = run(pick(a, ha, true), pick(b, hb, true), op);
+    if (ha.skippedFaces)
+        out = append(out, pick(a, ha, false));
+    if (op === 'union' && hb.skippedFaces)
+        out = append(out, pick(b, hb, false));
+    return out;
+};
+// A result is sound when it is a closed, outward solid with consistent winding (and the inputs were).
+const sound = (m) => {
+    if (!m.faces.length)
+        return true; // nothing is a fine result (disjoint intersect)
+    const v = validate(m);
+    return v.closed && !v.inside_out && !v.notes.some((n) => /wound inconsistently/.test(n));
+};
+const shiftBy = (m, d) => ({ ...m, positions: m.positions.map((p) => [p[0] + d[0], p[1] + d[1], p[2] + d[2]]) });
+/**
+ * BSP booleans hit numerical trouble when faces are (nearly) coincident or a cut passes within a hair of a vertex; the
+ * result then comes out with a crack or a flipped face. A solid must stay a solid, so a result that is not sound is
+ * thrown away and the operation is repeated with the second operand moved by a tiny amount (a few tries, growing).
+ * When no try gives a sound solid it throws, so the caller keeps the original.
+ */
+const run = (a, b, op) => {
+    const first = run0(a, b, op);
+    if (sound(first) || !sound(a) || !sound(b))
+        return first;
+    const size = Math.max(bounds(a).radius, bounds(b).radius, 1e-9);
+    for (let k = 1; k <= 12; k++) {
+        const mag = size * 1e-4 * k;
+        const d = [Math.sin(k * 12.9898) * mag, Math.sin(k * 78.233) * mag, Math.sin(k * 37.719) * mag];
+        const r = run0(a, shiftBy(b, d), op);
+        if (sound(r))
+            return r;
+    }
+    throw new Error('boolean: the result would not be a closed solid (numerical trouble); the operands were left alone');
+};
+const run0 = (a, b, op) => {
     const sa = bounds(a);
     const sb = bounds(b);
     const scale = Math.max(sa.radius, sb.radius, 1e-9) * 2 + len(sub(sa.center, sb.center));

package/dist/gpu.d.ts

@@ -30,6 +30,15 @@ export interface GpuRenderOptions {
         mesh: Mesh;
         data: Float32Array;
     };
+    /**
+     * Filmic look: lighting in linear colour, HDR light and emission, Fresnel on the edges, ACES tone mapping.
+     * `true` for the defaults or { exposure = 1, emit = 2 } (emit: brightness of one unit of material `emit`, which goes up to 5).
+     * Off by default (the plain flat look).
+     */
+    tonemap?: boolean | {
+        exposure?: number;
+        emit?: number;
+    };
 }
 /** One copy of a prototype: its position, orthonormal frame and color. */
 export interface Instance {

package/dist/gpu.js

@@ -71,6 +71,7 @@ struct U {
   ground : vec4<f32>,
   eye : vec4<f32>,
   mat : vec4<f32>,     // ambient, diffuse, specular, shininess
+  fx : vec4<f32>,      // filmic (0 or 1), exposure, emission gain
 };
 @group(0) @binding(0) var<uniform> u : U;
 
@@ -112,11 +113,47 @@ struct IIn {
   return o;
 }
 
+fn toLinear(c : vec3<f32>) -> vec3<f32> {
+  return select(pow((c + 0.055) / 1.055, vec3<f32>(2.4)), c / 12.92, c <= vec3<f32>(0.04045));
+}
+fn toSrgb(c : vec3<f32>) -> vec3<f32> {
+  return select(1.055 * pow(c, vec3<f32>(1.0 / 2.4)) - 0.055, c * 12.92, c <= vec3<f32>(0.0031308));
+}
+// ACES filmic curve (Narkowicz fit): highlights roll off softly instead of clipping
+fn aces(x : vec3<f32>) -> vec3<f32> {
+  return clamp((x * (2.51 * x + 0.03)) / (x * (2.43 * x + 0.59) + 0.14), vec3<f32>(0.0), vec3<f32>(1.0));
+}
+
+// The filmic path: the same light model, but in linear colour with HDR light and emission, then tone mapped.
+fn filmic(i : VOut, n : vec3<f32>, l : vec3<f32>, v : vec3<f32>) -> vec4<f32> {
+  let metal = i.m.x;
+  let rough = i.m.y;
+  let albedo = toLinear(i.c);
+  let hemi = mix(toLinear(u.ground.rgb), toLinear(u.sky.rgb), n.y * 0.5 + 0.5) * u.mat.x;
+  let diff = max(dot(n, l), 0.0) * u.mat.y * 1.6;
+  let h = normalize(l + v);
+  let shin = mix(u.mat.w * 7.0, u.mat.w * 0.15, rough);
+  let spec = pow(max(dot(n, h), 0.0), shin) * mix(u.mat.z, 1.0, metal) * mix(1.0, 0.35, rough) * step(0.0, dot(n, l)) * 2.5;
+  let r = reflect(-v, n);
+  // Schlick: edges mirror more, metal keeps its tint
+  let f0 = mix(vec3<f32>(0.04), albedo, metal);
+  let fres = f0 + (vec3<f32>(1.0) - f0) * pow(1.0 - max(dot(n, v), 0.0), 5.0) * (1.0 - rough);
+  let env = mix(toLinear(u.ground.rgb) * 1.2, toLinear(u.sky.rgb) * 1.5, smoothstep(-0.25 - rough * 0.5, 0.25 + rough * 0.5, r.y));
+  var lit = albedo * (hemi + vec3<f32>(diff)) * (1.0 - metal)
+          + albedo * env * metal * (1.0 - 0.6 * rough)
+          + env * fres * (1.0 - rough) * 0.5
+          + vec3<f32>(spec) * mix(vec3<f32>(1.0), albedo, metal);
+  // emission adds light, so a lamp can go above 1.0 and still keep its colour after tone mapping
+  lit = lit + albedo * i.m.w * u.fx.z;
+  return vec4<f32>(toSrgb(aces(lit * u.fx.y)), i.m.z);
+}
+
 @fragment fn fs(i : VOut, @builtin(front_facing) front : bool) -> @location(0) vec4<f32> {
   var n = normalize(i.n);
   if (!front) { n = -n; }
   let l = normalize(u.light.xyz);
   let v = normalize(u.eye.xyz - i.w);
+  if (u.fx.x > 0.5) { return filmic(i, n, l, v); }
   let metal = i.m.x;
   let rough = i.m.y;
   let hemi = mix(u.ground.rgb, u.sky.rgb, n.y * 0.5 + 0.5) * u.mat.x;
@@ -131,7 +168,7 @@ struct IIn {
   var lit = i.c * (hemi + vec3<f32>(diff)) * (1.0 - metal)
           + i.c * env * metal * (1.0 - 0.6 * rough)
           + vec3<f32>(spec) * mix(vec3<f32>(1.0), i.c, metal);
-  lit = mix(lit, i.c * 1.15, i.m.w);
+  lit = mix(lit, i.c * 1.15, min(i.m.w, 1.0)); // the plain look: emit 0..1 fades to flat colour, more does not add
   return vec4<f32>(clamp(lit, vec3<f32>(0.0), vec3<f32>(1.0)), i.m.z);
 }
 `;
@@ -171,19 +208,34 @@ export const createGpu = async (canvas, { sampleCount = 4 } = {}) => {
         stepMode: 'instance',
         attributes: [3, 4, 5, 6, 7].map((loc, k) => ({ shaderLocation: loc, offset: k * 12, format: 'float32x3' })),
     };
-    const make = (entry, buffers) => device.createRenderPipeline({
+    const make = (entry, buffers, glass = false) => device.createRenderPipeline({
         layout: 'auto',
         vertex: { module, entryPoint: entry, buffers },
-        fragment: { module, entryPoint: 'fs', targets: [{ format }] },
+        fragment: {
+            module,
+            entryPoint: 'fs',
+            targets: [
+                glass
+                    ? {
+                        format,
+                        blend: {
+                            color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                        },
+                    }
+                    : { format },
+            ],
+        },
         primitive: { topology: 'triangle-list', cullMode: 'none' },
-        depthStencil: { format: 'depth24plus', depthWriteEnabled: true, depthCompare: 'less' },
-        // the fragment alpha becomes coverage: a half transparent face covers half of the samples (one pass, no sorting)
-        multisample: sampleCount > 1 ? { count: sampleCount, alphaToCoverageEnabled: true } : { count: sampleCount },
+        // see-through faces (alpha < 1) are blended over what is behind them: they test depth but do not write it
+        depthStencil: { format: 'depth24plus', depthWriteEnabled: !glass, depthCompare: 'less' },
+        multisample: { count: sampleCount },
     });
     const pipeline = make('vs', [meshLayout]);
+    const glassPipeline = make('vs', [meshLayout], true);
     // the instanced pipeline reads position and normal only from the prototype (locations 0, 1)
     const instPipeline = make('vsi', [{ ...meshLayout, attributes: meshLayout.attributes.slice(0, 2) }, instanceLayout]);
-    const uniforms = device.createBuffer({ size: 144, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+    const uniforms = device.createBuffer({ size: 160, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
     const bind = device.createBindGroup({ layout: pipeline.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: uniforms } }] });
     const instBind = device.createBindGroup({ layout: instPipeline.getBindGroupLayout(0), entries: [{ binding: 0, resource: { buffer: uniforms } }] });
     // Geometry that did not change since the last frame is not rebuilt or uploaded again.
@@ -199,6 +251,12 @@ export const createGpu = async (canvas, { sampleCount = 4 } = {}) => {
     let instCount = 0;
     let vertexBuffer = null;
     let capacity = 0;
+    let glassBuffer = null; // the see-through triangles, sorted far to near for the eye
+    let glassCapacity = 0;
+    let glassTris = []; // centroid and offset (in floats) in glassSource
+    let glassSource = new Float32Array(0);
+    let glassCount = 0;
+    let glassEye = '';
     let px = 0;
     let depth = null;
     let color = null;
@@ -213,13 +271,30 @@ export const createGpu = async (canvas, { sampleCount = 4 } = {}) => {
         depth = device.createTexture({ size: [n, n], format: 'depth24plus', sampleCount, usage: GPUTextureUsage.RENDER_ATTACHMENT });
         color = sampleCount > 1 ? device.createTexture({ size: [n, n], format, sampleCount, usage: GPUTextureUsage.RENDER_ATTACHMENT }) : null;
     };
-    const draw = (mesh, view, { size = 400, fit, background = [0.98, 0.98, 0.97], light = {}, material = {}, palette, dpr = globalThis.devicePixelRatio || 1, instances } = {}, readback = false) => {
+    const draw = (mesh, view, { size = 400, fit, background = [0.98, 0.98, 0.97], light = {}, material = {}, palette, dpr = globalThis.devicePixelRatio || 1, instances, tonemap = false } = {}, readback = false) => {
         const L = { ...defaultLight, ...light };
+        const filmic = tonemap ? { exposure: 1, emit: 2, ...(tonemap === true ? {} : tonemap) } : null;
         const M = { ...defaultMaterial, ...material };
         const cam = makeCamera(view, mesh, size, fit);
         targets(Math.max(1, Math.round(size * dpr)));
         if (mesh !== uploaded || palette !== uploadedPalette) {
-            const verts = buildVertices(mesh, palette);
+            const all = buildVertices(mesh, palette);
+            // split: solid triangles are drawn first; triangles with alpha < 1 are kept apart and blended afterwards
+            const tri = 3 * FLOATS;
+            const solid = [];
+            glassTris = [];
+            for (let o = 0; o < all.length; o += tri) {
+                if (all[o + 11] < 1) {
+                    const c = [0, 1, 2].map((k) => (all[o + k] + all[o + FLOATS + k] + all[o + 2 * FLOATS + k]) / 3);
+                    glassTris.push({ c, at: o });
+                }
+                else
+                    for (let k = 0; k < tri; k++)
+                        solid.push(all[o + k]);
+            }
+            glassSource = all;
+            glassEye = '';
+            const verts = Float32Array.from(solid);
             if (verts.byteLength > capacity) {
                 vertexBuffer?.destroy();
                 capacity = Math.max(verts.byteLength, 4096);
@@ -253,13 +328,32 @@ export const createGpu = async (canvas, { sampleCount = 4 } = {}) => {
         }
         if (!instances)
             instCount = 0;
-        const u = new Float32Array(36);
+        const eyeKey = cam.eye.join(',');
+        if (glassTris.length && eyeKey !== glassEye) {
+            glassEye = eyeKey;
+            const [ex, ey, ez] = cam.eye;
+            const far = (t) => (t.c[0] - ex) ** 2 + (t.c[1] - ey) ** 2 + (t.c[2] - ez) ** 2;
+            const sorted = [...glassTris].sort((a, b) => far(b) - far(a)); // far first
+            const out = new Float32Array(sorted.length * 3 * FLOATS);
+            sorted.forEach((t, k) => out.set(glassSource.subarray(t.at, t.at + 3 * FLOATS), k * 3 * FLOATS));
+            if (out.byteLength > glassCapacity) {
+                glassBuffer?.destroy();
+                glassCapacity = Math.max(out.byteLength, 4096);
+                glassBuffer = device.createBuffer({ size: glassCapacity, usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST });
+            }
+            device.queue.writeBuffer(glassBuffer, 0, out);
+            glassCount = sorted.length * 3;
+        }
+        if (!glassTris.length)
+            glassCount = 0;
+        const u = new Float32Array(40);
         u.set(viewProjection(cam), 0);
         u.set([...(norm(L.direction)), 0], 16);
         u.set([...L.sky, 0], 20);
         u.set([...L.ground, 0], 24);
         u.set([...cam.eye, 0], 28);
         u.set([M.ambient, M.diffuse, M.specular, M.shininess], 32);
+        u.set([filmic ? 1 : 0, filmic ? filmic.exposure : 1, filmic ? filmic.emit : 0, 0], 36);
         device.queue.writeBuffer(uniforms, 0, u);
         const encoder = device.createCommandEncoder();
         const offscreen = readback
@@ -291,6 +385,13 @@ export const createGpu = async (canvas, { sampleCount = 4 } = {}) => {
             pass.setVertexBuffer(1, instBuffer);
             pass.draw(protoCount, instCount);
         }
+        if (glassCount) {
+            // after everything solid (and the instances): see-through faces, far to near
+            pass.setPipeline(glassPipeline);
+            pass.setBindGroup(0, bind);
+            pass.setVertexBuffer(0, glassBuffer);
+            pass.draw(glassCount);
+        }
         pass.end();
         if (!offscreen) {
             device.queue.submit([encoder.finish()]);
@@ -328,6 +429,7 @@ export const createGpu = async (canvas, { sampleCount = 4 } = {}) => {
     const pixels = (mesh, view, options) => draw(mesh, view, options, true);
     const destroy = () => {
         vertexBuffer?.destroy();
+        glassBuffer?.destroy();
         protoBuffer?.destroy();
         instBuffer?.destroy();
         depth?.destroy();

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 export declare const name: "3draft";
-export declare const version = "26.11.3001";
+export declare const version = "26.11.4010";
 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 } from './csg.js';
-export type { BooleanOp } from './csg.js';
+export { boolean, union, subtract, intersect, health } from './csg.js';
+export type { BooleanOp, Health, Part } from './csg.js';
 export type { Validation } from './check.js';
 export { extrudeFace, moveVertices } from './edit.js';
 export { VIEW_ORDER, makeCamera, orbit, project, ray } from './camera.js';
@@ -31,3 +31,5 @@ export interface Info {
 export declare const info: () => Info;
 export { initKernel } from './kernel.js';
 export type { Kernel } from './kernel.js';
+export { insertVertex, cutFace, moveVertex, fillLoop, addLine, findLoop, nearestSurface, wireFromSegments, moveVertexSet } from './wire.js';
+export type { Wire } from './wire.js';

package/dist/index.js

@@ -4,10 +4,10 @@
 // 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.3001';
+export const version = '26.11.4010';
 export { box, extrude, merge, rotate, bounds, faceNormal, faceCenter } from './mesh.js';
 export { validate } from './check.js';
-export { boolean, union, subtract, intersect } from './csg.js';
+export { boolean, union, subtract, intersect, health } from './csg.js';
 export { extrudeFace, moveVertices } from './edit.js';
 export { VIEW_ORDER, makeCamera, orbit, project, ray } from './camera.js';
 export { pick, crosshair } from './pick.js';
@@ -30,3 +30,4 @@ export const info = () => ({
     ],
 });
 export { initKernel } from './kernel.js';
+export { insertVertex, cutFace, moveVertex, fillLoop, addLine, findLoop, nearestSurface, wireFromSegments, moveVertexSet } from './wire.js';

package/dist/material.d.ts

@@ -6,9 +6,9 @@ export interface Material {
     metal?: number;
     /** 0 = mirror-like, 1 = matte; widens the highlight. */
     rough?: number;
-    /** 1 = solid, 0 = invisible. Drawn with alpha-to-coverage: one pass, no sorting. */
+    /** 1 = solid, 0 = invisible. Blended over what is behind it (WebGPU: a second pass, far to near). */
     alpha?: number;
-    /** 0..1: how much the color glows on its own, unlit. */
+    /** 0..5: how much the color glows on its own, unlit. Up to 1 it fades from lit to flat colour; above 1 (WebGPU `tonemap`) it is a light source: that many times brighter. */
     emit?: number;
 }
 export type Palette = Record<string, Material>;
@@ -20,6 +20,7 @@ export interface Surface {
     alpha: number;
     emit: number;
 }
+export declare const EMIT_MAX = 5;
 export declare const FALLBACK_COLOR = "#c8c8c8";
 export declare const DEFAULTS: {
     readonly metal: 0;

package/dist/material.js

@@ -1,7 +1,8 @@
 // Materials are data. A palette is a plain object { name: Material }; a face points at an entry by name
 // (`face.mat`) and keeps its own `color` as a fallback, so a mesh still looks right without the palette.
 // One shader draws all of them; the numbers below are the only knobs.
-const clamp01 = (n, fallback) => (typeof n === 'number' && Number.isFinite(n) ? Math.max(0, Math.min(1, n)) : fallback);
+const clamp = (n, fallback, max = 1) => (typeof n === 'number' && Number.isFinite(n) ? Math.max(0, Math.min(max, n)) : fallback);
+export const EMIT_MAX = 5;
 export const FALLBACK_COLOR = '#c8c8c8';
 export const DEFAULTS = { metal: 0, rough: 0.7, alpha: 1, emit: 0 };
 /** The surface of a face: its palette entry when it names one, else just its color with default properties. */
@@ -9,9 +10,9 @@ export const surfaceOf = (face, palette) => {
     const m = face.mat !== undefined ? palette?.[face.mat] : undefined;
     return {
         color: m?.color ?? face.color ?? FALLBACK_COLOR,
-        metal: clamp01(m?.metal, DEFAULTS.metal),
-        rough: clamp01(m?.rough, DEFAULTS.rough),
-        alpha: clamp01(m?.alpha, DEFAULTS.alpha),
-        emit: clamp01(m?.emit, DEFAULTS.emit),
+        metal: clamp(m?.metal, DEFAULTS.metal),
+        rough: clamp(m?.rough, DEFAULTS.rough),
+        alpha: clamp(m?.alpha, DEFAULTS.alpha),
+        emit: clamp(m?.emit, DEFAULTS.emit, EMIT_MAX),
     };
 };

package/dist/wire.d.ts

@@ -0,0 +1,57 @@
+import type { Mesh, Vec3, Face } from './types.js';
+/** Lines drawn on / off a mesh: pairs of vertex indices. */
+export type Wire = [number, number][];
+/**
+ * Puts a vertex at `point`, which lies on face `face`. On an existing vertex it returns that one; on an edge it is
+ * added to both faces that share the edge (no crack); inside the face it splits the face into triangles around it.
+ * { mesh, index }
+ */
+export declare const insertVertex: (mesh: Mesh, face: number, point: Vec3) => {
+    mesh: Mesh;
+    index: number;
+};
+/**
+ * Cuts the face that holds vertices `a` and `b` (not next to each other) along the line a-b: two convex faces.
+ * `cut` is false when no face holds both, or they are already neighbours on every face.
+ */
+export declare const cutFace: (mesh: Mesh, a: number, b: number) => {
+    mesh: Mesh;
+    cut: boolean;
+};
+/** Moves vertex `i` to `to`. Polygons that use it become triangles, so every face stays planar. */
+export declare const moveVertex: (mesh: Mesh, i: number, to: Vec3) => Mesh;
+/**
+ * A face from a closed loop of vertices. It is wound to point away from `awayFrom` (default: the middle of the
+ * mesh), which is what a patch closing a gap in a surface wants; 4 or more vertices become a fan of triangles.
+ */
+export declare const fillLoop: (mesh: Mesh, loop: number[], face?: Partial<Face>, awayFrom?: Vec3) => Mesh;
+/** Adds the line a-b (not twice, not a point). */
+export declare const addLine: (wire: Wire, a: number, b: number) => Wire;
+/**
+ * The shortest closed loop of lines through line [a, b], at most `max` vertices: [a, ..., b], or null.
+ * Close it with fillLoop.
+ */
+export declare const findLoop: (wire: Wire, [a, b]: [number, number], max?: number) => number[] | null;
+/**
+ * The surface point of the mesh nearest to `p`, if it is within `tolerance`: { face, point } (point lies on the face),
+ * otherwise null. For placing a point that was drawn near a surface on the surface.
+ */
+export declare const nearestSurface: (mesh: Mesh, p: Vec3, tolerance: number) => {
+    face: number;
+    point: Vec3;
+} | null;
+/**
+ * Turns line segments (pairs of points) into wire on the mesh: each end becomes a vertex (an existing one within
+ * `tolerance`, a new one on the surface when it is near it, otherwise a free point in the air), each segment a line,
+ * and two ends on one face cut that face. Returns the new mesh and wire.
+ */
+export declare const wireFromSegments: (mesh: Mesh, wire: Wire, segments: [Vec3, Vec3][], tolerance: number) => {
+    mesh: Mesh;
+    wire: Wire;
+};
+/**
+ * Moves several vertices at once: `moves` is [[index, newPosition], ...]. A polygon whose vertices all moved by the
+ * same step (a face dragged as a whole) stays as it is; any other polygon that uses a moved vertex becomes triangles,
+ * so every face stays planar.
+ */
+export declare const moveVertexSet: (mesh: Mesh, moves: [number, Vec3][]) => Mesh;

package/dist/wire.js

@@ -0,0 +1,244 @@
+// Drawing on a mesh: put a vertex on a surface, cut a face along a line between two vertices,
+// move a vertex, close a loop of lines into a face. The wire is a list of [a, b] vertex pairs next to the mesh:
+// its ends are ordinary mesh vertices, so moving a vertex moves every line (and every face) that uses it.
+// Faces stay convex and planar: a vertex placed inside a face splits it into triangles, a cut splits a convex
+// polygon into two convex ones, and a moved vertex turns the polygons it touches into triangles.
+import { sub, add, scale, dot, len } from './vec.js';
+import { faceNormal, bounds } from './mesh.js';
+const sizeOf = (mesh) => bounds(mesh).radius || 1;
+/** Distance from `p` to the segment a-b, and where along it (0..1). */
+const toSegment = (p, a, b) => {
+    const ab = sub(b, a);
+    const l2 = dot(ab, ab) || 1;
+    const t = Math.max(0, Math.min(1, dot(sub(p, a), ab) / l2));
+    return { distance: len(sub(p, add(a, scale(ab, t)))), t };
+};
+const withFaces = (mesh, faces, positions = mesh.positions) => ({ ...mesh, positions, faces });
+/**
+ * Puts a vertex at `point`, which lies on face `face`. On an existing vertex it returns that one; on an edge it is
+ * added to both faces that share the edge (no crack); inside the face it splits the face into triangles around it.
+ * { mesh, index }
+ */
+export const insertVertex = (mesh, face, point) => {
+    const eps = 1e-6 * sizeOf(mesh);
+    const f = mesh.faces[face];
+    const { positions } = mesh;
+    for (const v of f.v)
+        if (len(sub(positions[v], point)) <= eps * 10)
+            return { mesh, index: v };
+    const index = positions.length;
+    const next = [...positions, point];
+    const m = f.v.length;
+    for (let j = 0; j < m; j++) {
+        const a = f.v[j];
+        const b = f.v[(j + 1) % m];
+        if (toSegment(point, positions[a], positions[b]).distance > eps * 10)
+            continue;
+        // on the edge a-b: every face holding that edge (same positions, either direction) gets the new vertex
+        const faces = mesh.faces.map((g, gi) => {
+            const n = g.v.length;
+            for (let k = 0; k < n; k++) {
+                const p = positions[g.v[k]];
+                const q = positions[g.v[(k + 1) % n]];
+                const same = (len(sub(p, positions[a])) <= eps && len(sub(q, positions[b])) <= eps) || (len(sub(p, positions[b])) <= eps && len(sub(q, positions[a])) <= eps);
+                if (same)
+                    return { ...g, v: [...g.v.slice(0, k + 1), index, ...g.v.slice(k + 1)] };
+            }
+            return gi === face ? g : g;
+        });
+        return { mesh: withFaces(mesh, faces, next), index };
+    }
+    // inside: a fan of triangles around the new vertex, same side as the face
+    const fan = f.v.map((v, j) => ({ ...f, v: [v, f.v[(j + 1) % m], index] }));
+    return { mesh: withFaces(mesh, [...mesh.faces.slice(0, face), ...fan, ...mesh.faces.slice(face + 1)], next), index };
+};
+/**
+ * Cuts the face that holds vertices `a` and `b` (not next to each other) along the line a-b: two convex faces.
+ * `cut` is false when no face holds both, or they are already neighbours on every face.
+ */
+export const cutFace = (mesh, a, b) => {
+    for (let fi = 0; fi < mesh.faces.length; fi++) {
+        const f = mesh.faces[fi];
+        const ia = f.v.indexOf(a);
+        const ib = f.v.indexOf(b);
+        if (ia < 0 || ib < 0)
+            continue;
+        const m = f.v.length;
+        if ((ia - ib + m) % m === 1 || (ib - ia + m) % m === 1)
+            continue;
+        const walk = (from, to) => {
+            const out = [f.v[from]];
+            for (let k = from; k !== to;) {
+                k = (k + 1) % m;
+                out.push(f.v[k]);
+            }
+            return out;
+        };
+        const faces = [...mesh.faces.slice(0, fi), { ...f, v: walk(ia, ib) }, { ...f, v: walk(ib, ia) }, ...mesh.faces.slice(fi + 1)];
+        return { mesh: withFaces(mesh, faces), cut: true };
+    }
+    return { mesh, cut: false };
+};
+/** Moves vertex `i` to `to`. Polygons that use it become triangles, so every face stays planar. */
+export const moveVertex = (mesh, i, to) => {
+    const positions = mesh.positions.map((p, k) => (k === i ? to : p));
+    const faces = [];
+    for (const f of mesh.faces) {
+        if (f.v.length <= 3 || !f.v.includes(i))
+            faces.push(f);
+        else
+            for (let j = 1; j < f.v.length - 1; j++)
+                faces.push({ ...f, v: [f.v[0], f.v[j], f.v[j + 1]] });
+    }
+    return withFaces(mesh, faces, positions);
+};
+/**
+ * A face from a closed loop of vertices. It is wound to point away from `awayFrom` (default: the middle of the
+ * mesh), which is what a patch closing a gap in a surface wants; 4 or more vertices become a fan of triangles.
+ */
+export const fillLoop = (mesh, loop, face = {}, awayFrom = bounds(mesh).center) => {
+    if (loop.length < 3)
+        return mesh;
+    const pts = loop.map((v) => mesh.positions[v]);
+    const centre = scale(pts.reduce((s, p) => add(s, p), [0, 0, 0]), 1 / pts.length);
+    const ordered = dot(faceNormal(pts), sub(centre, awayFrom)) >= 0 ? loop : [...loop].reverse();
+    const out = [];
+    for (let j = 1; j < ordered.length - 1; j++)
+        out.push({ ...face, v: [ordered[0], ordered[j], ordered[j + 1]] });
+    return withFaces(mesh, [...mesh.faces, ...out]);
+};
+/** Adds the line a-b (not twice, not a point). */
+export const addLine = (wire, a, b) => (a === b || wire.some(([p, q]) => (p === a && q === b) || (p === b && q === a)) ? wire : [...wire, [a, b]]);
+/**
+ * The shortest closed loop of lines through line [a, b], at most `max` vertices: [a, ..., b], or null.
+ * Close it with fillLoop.
+ */
+export const findLoop = (wire, [a, b], max = 8) => {
+    const near = new Map();
+    for (const [p, q] of wire) {
+        if ((p === a && q === b) || (p === b && q === a))
+            continue; // not through the line itself
+        near.set(p, [...(near.get(p) ?? []), q]);
+        near.set(q, [...(near.get(q) ?? []), p]);
+    }
+    const from = new Map([[a, -1]]);
+    const queue = [a];
+    for (let head = 0; head < queue.length; head++) {
+        const v = queue[head];
+        if (v === b)
+            break;
+        for (const w of near.get(v) ?? [])
+            if (!from.has(w))
+                (from.set(w, v), queue.push(w));
+    }
+    if (!from.has(b))
+        return null;
+    const path = [];
+    for (let v = b; v !== -1; v = from.get(v))
+        path.unshift(v);
+    return path.length <= max ? path : null;
+};
+/** The point of triangle a-b-c closest to p (Ericson, Real-Time Collision Detection). */
+const closestOnTriangle = (p, a, b, c) => {
+    const ab = sub(b, a);
+    const ac = sub(c, a);
+    const ap = sub(p, a);
+    const d1 = dot(ab, ap);
+    const d2 = dot(ac, ap);
+    if (d1 <= 0 && d2 <= 0)
+        return a;
+    const bp = sub(p, b);
+    const d3 = dot(ab, bp);
+    const d4 = dot(ac, bp);
+    if (d3 >= 0 && d4 <= d3)
+        return b;
+    const vc = d1 * d4 - d3 * d2;
+    if (vc <= 0 && d1 >= 0 && d3 <= 0)
+        return add(a, scale(ab, d1 / (d1 - d3)));
+    const cp = sub(p, c);
+    const d5 = dot(ab, cp);
+    const d6 = dot(ac, cp);
+    if (d6 >= 0 && d5 <= d6)
+        return c;
+    const vb = d5 * d2 - d1 * d6;
+    if (vb <= 0 && d2 >= 0 && d6 <= 0)
+        return add(a, scale(ac, d2 / (d2 - d6)));
+    const va = d3 * d6 - d5 * d4;
+    if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0)
+        return add(b, scale(sub(c, b), (d4 - d3) / (d4 - d3 + (d5 - d6))));
+    const denom = 1 / (va + vb + vc);
+    return add(a, add(scale(ab, vb * denom), scale(ac, vc * denom)));
+};
+/**
+ * The surface point of the mesh nearest to `p`, if it is within `tolerance`: { face, point } (point lies on the face),
+ * otherwise null. For placing a point that was drawn near a surface on the surface.
+ */
+export const nearestSurface = (mesh, p, tolerance) => {
+    let best = null;
+    mesh.faces.forEach((f, face) => {
+        const pts = f.v.map((v) => mesh.positions[v]);
+        for (let j = 1; j < pts.length - 1; j++) {
+            const q = closestOnTriangle(p, pts[0], pts[j], pts[j + 1]);
+            const d = len(sub(q, p));
+            if (d <= tolerance && (!best || d < best.d))
+                best = { face, point: q, d };
+        }
+    });
+    return best ? { face: best.face, point: best.point } : null;
+};
+/**
+ * Turns line segments (pairs of points) into wire on the mesh: each end becomes a vertex (an existing one within
+ * `tolerance`, a new one on the surface when it is near it, otherwise a free point in the air), each segment a line,
+ * and two ends on one face cut that face. Returns the new mesh and wire.
+ */
+export const wireFromSegments = (mesh, wire, segments, tolerance) => {
+    let m = mesh;
+    let w = wire;
+    const vertexAt = (p) => {
+        const near = m.positions.findIndex((q) => len(sub(q, p)) <= tolerance);
+        if (near >= 0)
+            return near;
+        const s = nearestSurface(m, p, tolerance);
+        if (s) {
+            const r = insertVertex(m, s.face, s.point);
+            m = r.mesh;
+            return r.index;
+        }
+        m = { ...m, positions: [...m.positions, p] };
+        return m.positions.length - 1;
+    };
+    for (const [a, b] of segments) {
+        const ia = vertexAt(a);
+        const ib = vertexAt(b);
+        if (ia === ib)
+            continue;
+        w = addLine(w, ia, ib);
+        m = cutFace(m, ia, ib).mesh;
+    }
+    return { mesh: m, wire: w };
+};
+/**
+ * Moves several vertices at once: `moves` is [[index, newPosition], ...]. A polygon whose vertices all moved by the
+ * same step (a face dragged as a whole) stays as it is; any other polygon that uses a moved vertex becomes triangles,
+ * so every face stays planar.
+ */
+export const moveVertexSet = (mesh, moves) => {
+    const to = new Map(moves);
+    const positions = mesh.positions.map((p, k) => to.get(k) ?? p);
+    const step = (v) => sub(positions[v], mesh.positions[v]);
+    const faces = [];
+    for (const f of mesh.faces) {
+        if (f.v.length <= 3 || !f.v.some((v) => to.has(v))) {
+            faces.push(f);
+            continue;
+        }
+        const first = step(f.v[0]);
+        const rigid = f.v.every((v) => len(sub(step(v), first)) < 1e-9 * (bounds(mesh).radius || 1));
+        if (rigid)
+            faces.push(f);
+        else
+            for (let j = 1; j < f.v.length - 1; j++)
+                faces.push({ ...f, v: [f.v[0], f.v[j], f.v[j + 1]] });
+    }
+    return withFaces(mesh, faces, positions);
+};

package/package.json

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