@reekon-tools/boldr-cad 0.1.0 → 1.0.0

package/src/view3d/build.ts

@@ -0,0 +1,607 @@
+import { openingHeights, toU, wallHeight } from '../model/elevation';
+import { faceKeyParts } from '../model/faces';
+import { faceFrame, UPPER_Z } from '../model/facesolve';
+import { hyp, normAng } from '../model/geom';
+import { edgeS, openingSpan } from '../model/openings';
+import { curveFrame, wallThick } from '../model/planGeom';
+import { roomGeom } from '../model/rooms';
+import { settings } from '../model/settings';
+import { roomValid, withLineIndex } from '../model/sketch';
+import type { Opening, Sketch, XY } from '../model/types';
+import { wallPieces } from '../model/wallshape';
+import { boxLines, cellLines, mergeIv, raiseIn, type Cell3 } from './lines';
+import { PartBuilder, type Mat3, type Part3, type V3 } from './mesh';
+import { area, clipBand, clipHalf, clipSpan, tidy } from './poly';
+
+/*
+  The 3D view's model, made again from the plan whenever it changes: each wall stood up to its height with its doors
+  and windows cut through it, curved walls as bands, each space's floor, and the cabinets from the wall views. Plain
+  triangles (no three.js here), so it's tested like the rest of the model.
+
+  Walls of different heights: each goes up to its own height, and where walls meet the joint goes up to the tallest of
+  them — the taller wall runs on through the corner and the shorter one stops against it, as it would be framed. A
+  wall ending on the middle of another stops at that wall's face, and runs on over it only where it's the taller.
+
+  Cutaway: the walls between the camera and the middle of the plan drop to CUT_H, so the rooms can be seen into. A
+  cabinet hung above the cut goes with its wall.
+*/
+
+/** How low the walls in front drop in a cutaway, inches: under most windows, over a counter. */
+export const CUT_H = 36;
+
+/** A countertop's thickness, on a base cabinet. */
+const COUNTER = 1.5;
+
+/** The walls between the camera and `c`, the middle of the plan, are cut down to `h`. */
+export interface Cut3 {
+  /** the middle of the plan */
+  c: XY;
+  /** level, from there toward the camera (unit length) */
+  d: XY;
+  h: number;
+}
+
+export interface Scene3 {
+  parts: Part3[];
+  /** the box it all fits in, [x, y, z] */
+  min: V3;
+  max: V3;
+  /** what the cutaway lowered: straight walls by id, stretches of curved ones as "<id>#<n>" */
+  lowered: string[];
+  /** the outlines of the walls and what's on them, as line segments (x, y, z of each end) */
+  lines: number[];
+}
+
+/** Whether a stretch of wall at `m` (facing `n`, either way) stands between the camera and the plan's middle. */
+export function inFront(cut: Cut3, m: XY, n: XY): boolean {
+  return (m.x - cut.c.x) * cut.d.x + (m.y - cut.c.y) * cut.d.y > 0 && Math.abs(n.x * cut.d.x + n.y * cut.d.y) > 0.35;
+}
+
+interface Wall3 { id: string; A: XY; B: XY; u: XY; L: number; t: number; h: number; full: number }
+
+interface Opening3 { id: string; type: Opening['type']; s0: number; s1: number; sill: number; head: number; flip: boolean }
+
+/** The plan's straight walls, each at its height (cut down when it's in front of a cutaway). */
+function straightWalls(sk: Sketch, cut: Cut3 | null, lowered: string[]): Map<string, Wall3> {
+  const out = new Map<string, Wall3>();
+  for (const [id, l] of Object.entries(sk.lines)) {
+    if (l.kind !== 'wall' || l.constr) continue;
+    const A = sk.points[l.a], B = sk.points[l.b];
+    if (!A || !B) continue;
+    const L = hyp(B.x - A.x, B.y - A.y);
+    if (L < 1e-6) continue;
+    const u = { x: (B.x - A.x) / L, y: (B.y - A.y) / L }, full = wallHeight(l);
+    let h = full;
+    if (cut && full > cut.h && inFront(cut, { x: (A.x + B.x) / 2, y: (A.y + B.y) / 2 }, { x: -u.y, y: u.x })) {
+      h = cut.h;
+      lowered.push(id);
+    }
+    out.set(id, { id, A, B, u, L, t: l.thick, h, full });
+  }
+  return out;
+}
+
+/**
+ * The curved walls: each one's centre, radius, start angle and sweep, thickness, the height of each stretch, an arc's
+ * end points, and how an end that meets straight walls is cut (on a mitre to them, set by the joints).
+ */
+interface Curve3 {
+  id: string; o: XY; r: number; t0: number; sweep: number; arc: boolean; t: number; hs: number[];
+  /** an arc's points at its start (t0) and its end */
+  pa?: string; pb?: string;
+  start?: Mitre3; end?: Mitre3;
+}
+/** An end cut on a mitre: through its end point P, from its inside corner to its outside one. */
+interface Mitre3 { P: XY; inner: XY; outer: XY }
+
+function curvedWalls(sk: Sketch, cut: Cut3 | null, lowered: string[]): Curve3[] {
+  const out: Curve3[] = [], full = settings.wallH;
+  for (const id of [...Object.keys(sk.circles), ...Object.keys(sk.arcs)]) {
+    const c = sk.circles[id] ?? sk.arcs[id];
+    if (!c || c.kind !== 'wall' || c.constr) continue;
+    const f = curveFrame(sk, id);
+    if (!f || f.r < 1e-3) continue;
+    const t0 = f.arc ? f.arc.t0 : 0, sweep = f.arc ? normAng(f.arc.t1 - f.arc.t0) : 2 * Math.PI;
+    if (sweep < 1e-6) continue;
+    // a stretch every 4° or so
+    const n = Math.max(f.arc ? 2 : 12, Math.ceil(sweep / (Math.PI / 45))), hs: number[] = [];
+    for (let i = 0; i < n; i++) {
+      const tm = t0 + (sweep * (i + 0.5)) / n, rad = { x: Math.cos(tm), y: Math.sin(tm) };
+      const low = !!cut && full > cut.h && inFront(cut, { x: f.o.x + rad.x * f.r, y: f.o.y + rad.y * f.r }, rad);
+      if (low) lowered.push(id + '#' + i);
+      hs.push(low ? cut!.h : full);
+    }
+    const a = f.arc ? sk.arcs[id] : null;
+    out.push({ id, o: f.o, r: f.r, t0, sweep, arc: !!f.arc, t: wallThick(c), hs, ...(a ? { pa: a.a, pb: a.b } : {}) });
+  }
+  return out;
+}
+
+/** Which walls a cutaway from `cut` lowers (as Scene3.lowered), without building anything: to tell when it changes. */
+export function loweredBy(sk: Sketch, cut: Cut3 | null): string[] {
+  const lowered: string[] = [];
+  straightWalls(sk, cut, lowered);
+  curvedWalls(sk, cut, lowered);
+  return lowered;
+}
+
+const near = (p: XY, q: XY) => hyp(p.x - q.x, p.y - q.y) < 1e-6;
+const sideways = (a: XY, b: XY) => Math.abs(a.x * b.y - a.y * b.x) > 0.02;
+/** The same polygon (the same corners, whichever it starts from). */
+const samePoly = (p: XY[], q: XY[]) => p.length === q.length && p.every(a => q.some(b => near(a, b)));
+
+/** Each wall's doors and windows (as the plan lists them): asked of each wall, once for all of them. */
+function openingsByWall(sk: Sketch): Map<string, [string, Opening][]> {
+  const out = new Map<string, [string, Opening][]>();
+  for (const e of Object.entries(sk.openings)) (out.get(e[1].line) ?? out.set(e[1].line, []).get(e[1].line)!).push(e);
+  return out;
+}
+
+/**
+ * The doors and windows in wall `w` (`mine`, from openingsByWall): where each runs along it and its sill and head (none
+ * above the wall's top).
+ */
+function openingsIn(sk: Sketch, w: Wall3, mine: [string, Opening][]): Opening3[] {
+  const out: Opening3[] = [];
+  for (const [id, o] of mine) {
+    const g = openingSpan(sk, o);
+    if (!g) continue;
+    const a = edgeS(o, g.w, 's0'), b = edgeS(o, g.w, 's1');
+    const s0 = Math.max(0, Math.min(a, b)), s1 = Math.min(w.L, Math.max(a, b));
+    if (s1 - s0 < 0.01) continue;
+    const { sill, head } = openingHeights(o);
+    out.push({ id, type: o.type, s0, s1, sill: Math.min(sill, w.h), head: Math.min(head, w.h), flip: !!o.flip });
+  }
+  return out.sort((p, q) => p.s0 - q.s0);
+}
+
+/**
+ * Wall `w` stood up over its outline `poly` (counter-clockwise), its doors and windows cut through: its top (dark: a
+ * cut through the wall — not over an opening that runs up to it), its ends, its two long faces with a hole for each
+ * opening, and each opening's sides, sill and head (the wall's own faces). Where an opening's edge meets a face, both
+ * have a corner there, so they join without a seam.
+ */
+function standWall(b: PartBuilder, w: Wall3, poly: XY[], ops: Opening3[]): void {
+  const holes = ops.filter(o => o.head - o.sill > 0.01);
+  let from = -1e9;
+  for (const [s0, s1] of [...holes.filter(o => o.head >= w.h - 1e-6).map(o => [o.s0, o.s1]), [1e9, 1e9]]) {
+    if (s0 > from + 1e-6) {
+      const top = tidy(clipSpan(poly, w.A, w.u, from, s0));
+      if (top.length >= 3 && area(top) > 1e-6) b.cap('top', top, w.h);
+    }
+    from = Math.max(from, s1);
+  }
+  const nx = -w.u.y, ny = w.u.x, off = (p: XY) => (p.x - w.A.x) * nx + (p.y - w.A.y) * ny;
+  const sOf = (p: XY) => (p.x - w.A.x) * w.u.x + (p.y - w.A.y) * w.u.y;
+  /** each long face: the point on it at s along the wall */
+  const faces: ((s: number) => XY)[] = [];
+  for (let i = 0; i < poly.length; i++) {
+    const pa = poly[i], pb = poly[(i + 1) % poly.length], dx = pb.x - pa.x, dy = pb.y - pa.y, L = Math.hypot(dx, dy);
+    if (L < 1e-9) continue;
+    const out: V3 = [dy / L, -dx / L, 0], k = off(pa);
+    const long = holes.length > 0 && Math.abs(dx * w.u.y - dy * w.u.x) < 1e-6 * L && Math.abs(Math.abs(k) - w.t / 2) < 1e-6 && Math.abs(off(pb) - k) < 1e-6;
+    if (!long) { b.quad('wall', [pa.x, pa.y, 0], [pb.x, pb.y, 0], [pb.x, pb.y, w.h], [pa.x, pa.y, w.h], out); continue; }
+    const sa = sOf(pa), sb = sOf(pb);
+    const at = (s: number): XY => (s === sa ? pa : s === sb ? pb : { x: pa.x + dx * ((s - sa) / (sb - sa)), y: pa.y + dy * ((s - sa) / (sb - sa)) });
+    faces.push(at);
+    longFace(b, w.h, Math.min(sa, sb), Math.max(sa, sb), holes, at, out);
+  }
+  if (faces.length !== 2) return;
+  const [f, g] = faces, P = (face: (s: number) => XY, s: number, z: number): V3 => { const p = face(s); return [p.x, p.y, z]; };
+  for (const o of holes) {
+    // its sides face into it; under a window its sill, over it (and over a door) its head
+    b.quad('wall', P(f, o.s0, o.sill), P(g, o.s0, o.sill), P(g, o.s0, o.head), P(f, o.s0, o.head), [w.u.x, w.u.y, 0]);
+    b.quad('wall', P(f, o.s1, o.sill), P(g, o.s1, o.sill), P(g, o.s1, o.head), P(f, o.s1, o.head), [-w.u.x, -w.u.y, 0]);
+    if (o.sill > 0.01) b.quad('wall', P(f, o.s0, o.sill), P(g, o.s0, o.sill), P(g, o.s1, o.sill), P(f, o.s1, o.sill), [0, 0, 1]);
+    if (o.head < w.h - 0.01) b.quad('wall', P(f, o.s0, o.head), P(g, o.s0, o.head), P(g, o.s1, o.head), P(f, o.s1, o.head), [0, 0, -1]);
+  }
+}
+
+/**
+ * One long face of a wall, lo to hi along it (`at`: the point on it at s), with a hole for each opening: strips
+ * between the openings' edges — full height, or under a sill and over a head — each with a corner wherever the strip
+ * beside it, or the opening's own side, has one on the edge they share.
+ */
+function longFace(b: PartBuilder, h: number, lo: number, hi: number, holes: Opening3[], at: (s: number) => XY, out: V3): void {
+  const hs = holes.filter(o => o.s1 > lo + 1e-6 && o.s0 < hi - 1e-6);
+  const cuts = [...new Set([lo, hi, ...hs.flatMap(o => [Math.max(lo, o.s0), Math.min(hi, o.s1)])])].sort((p, q) => p - q);
+  /** the heights the edge at s has corners at: the sill and head of an opening whose side it is */
+  const edgeZ = (s: number) => hs.filter(o => o.s0 === s || o.s1 === s).flatMap(o => [o.sill, o.head]);
+  const P = (s: number, z: number): V3 => { const p = at(s); return [p.x, p.y, z]; };
+  for (let i = 0; i + 1 < cuts.length; i++) {
+    const p = cuts[i], q = cuts[i + 1];
+    if (q - p < 1e-6) continue;
+    const o = hs.find(o => o.s0 <= p + 1e-6 && o.s1 >= q - 1e-6);
+    for (const [z0, z1] of o ? [[0, o.sill], [o.head, h]] : [[0, h]]) {
+      if (z1 - z0 < 1e-6) continue;
+      const within = (z: number) => z > z0 + 1e-6 && z < z1 - 1e-6;
+      const up = [...new Set(edgeZ(q).filter(within))].sort((a, c) => a - c), down = [...new Set(edgeZ(p).filter(within))].sort((a, c) => c - a);
+      b.fan('wall', [P(p, z0), P(q, z0), ...up.map(z => P(q, z)), P(q, z1), P(p, z1), ...down.map(z => P(p, z))], out);
+    }
+  }
+}
+
+/**
+ * Wall `w` seen from above for its outlines: its outline cut across at its openings' sides, each part solid as the
+ * wall is there (under a sill and over a head, at an opening).
+ */
+function wallCells(w: Wall3, poly: XY[], ops: Opening3[]): Cell3[] {
+  const cuts = [...new Set(ops.flatMap(o => [o.s0, o.s1]))].sort((p, q) => p - q), at = [-1e9, ...cuts, 1e9], out: Cell3[] = [];
+  for (let i = 0; i + 1 < at.length; i++) {
+    const s0 = at[i], s1 = at[i + 1];
+    if (s1 - s0 < 1e-6) continue;
+    const slice = tidy(clipSpan(poly, w.A, w.u, s0, s1));
+    if (slice.length < 3 || area(slice) < 1e-6) continue;
+    const o = ops.find(o => o.s0 <= s0 + 1e-6 && o.s1 >= s1 - 1e-6);
+    out.push({ poly: slice, iv: mergeIv(o ? [[0, o.sill], [o.head, w.h]] : [[0, w.h]]) });
+  }
+  return out;
+}
+
+/** A door's frame, inches: how thick its lining is, how wide and deep its casings are, how thick its leaf, how far it's open. */
+const FRAME = 0.75, CASING = 2.5, CASING_OUT = 0.625, LEAF = 1.375, OPEN = (30 * Math.PI) / 180;
+
+/**
+ * A door, so it reads as one: the floor run on through the doorway, a frame lining its sides and head, casings round
+ * it on both faces (as high as the wall goes), and its leaf — hinged at its first side on the face it swings to, as the
+ * plan draws it, and open a little. Its outlines go on `lines`.
+ */
+function doorPart(w: Wall3, o: Opening3, lines: number[]): PartBuilder {
+  const b = new PartBuilder('opening', o.id), half = w.t / 2, head = Math.min(o.head, w.h), nx = -w.u.y, ny = w.u.x;
+  const P = (s: number, k: number): XY => ({ x: w.A.x + w.u.x * s + nx * k, y: w.A.y + w.u.y * s + ny * k });
+  const rect = (s0: number, s1: number, k0: number, k1: number) => [P(s0, k0), P(s1, k0), P(s1, k1), P(s0, k1)];
+  const box = (poly: XY[], z0: number, z1: number, mat: Mat3) => {
+    const pp = tidy(poly);
+    if (z1 - z0 < 1e-3 || pp.length < 3 || area(pp) < 1e-6) return;
+    b.prism(pp, z0, z1, mat, mat);
+    for (const v of boxLines(pp, z0, z1)) lines.push(v);
+  };
+  b.cap('floor', tidy(rect(o.s0, o.s1, -half, half)), 0);
+  box(rect(o.s0, o.s0 + FRAME, -half, half), 0, head, 'frame');
+  box(rect(o.s1 - FRAME, o.s1, -half, half), 0, head, 'frame');
+  box(rect(o.s0 + FRAME, o.s1 - FRAME, -half, half), head - FRAME, head, 'frame');
+  const top = Math.min(head + CASING, w.h);
+  for (const k of [1, -1]) {
+    const k0 = k * half, k1 = k * (half + CASING_OUT);
+    box(rect(o.s0 - CASING, o.s0, k0, k1), 0, top, 'frame');
+    box(rect(o.s1, o.s1 + CASING, k0, k1), 0, top, 'frame');
+    box(rect(o.s0, o.s1, k0, k1), head, top, 'frame');
+  }
+  const f = o.flip ? -1 : 1, W = o.s1 - o.s0 - 2 * FRAME, H = head - FRAME - 0.5;
+  if (W > 2 && H > 2) {
+    // (turned about its hinge, at the frame on the face it swings to, toward that face)
+    const hs = o.s0 + FRAME, hk = f * half, c = Math.cos(f * OPEN), sn = Math.sin(f * OPEN);
+    const R = (s: number, k: number): XY => P(hs + (s - hs) * c - (k - hk) * sn, hk + (s - hs) * sn + (k - hk) * c);
+    box([R(hs, hk), R(hs + W, hk), R(hs + W, hk - f * LEAF), R(hs, hk - f * LEAF)], 0.5, 0.5 + H, 'door');
+  }
+  return b;
+}
+
+/** A window's glass on its wall's centreline, or a doorway's (unseen) face to tap. */
+function openingPart(w: Wall3, o: Opening3): Part3 | null {
+  const p = new PartBuilder('opening', o.id), n: V3 = [-w.u.y, w.u.x, 0];
+  const a = { x: w.A.x + w.u.x * o.s0, y: w.A.y + w.u.y * o.s0 }, c = { x: w.A.x + w.u.x * o.s1, y: w.A.y + w.u.y * o.s1 };
+  const z0 = o.type === 'window' ? o.sill : 0, z1 = o.head;
+  if (z1 - z0 < 0.01) return null;
+  p.quad(o.type === 'window' ? 'glass' : 'pick', [a.x, a.y, z0], [c.x, c.y, z0], [c.x, c.y, z1], [a.x, a.y, z1], n);
+  return p;
+}
+
+/** What an edge of a curved wall's stretch is: across it at its start or end, or along its outside or inside face. */
+type Edge3 = 'a' | 'e' | 'out' | 'in';
+/** One stretch of a curved wall seen from above (counter-clockwise), what each of its edges is, and its height. */
+interface Seg3 { pts: XY[]; edges: Edge3[]; h: number }
+
+/** A curved wall's stretches: each from its inside to its outside face, the first and last cut on a mitre where straight walls meet them. */
+function curveSegments(c: Curve3): Seg3[] {
+  const n = c.hs.length, ri = Math.max(0.05, c.r - c.t / 2), ro = c.r + c.t / 2, out: Seg3[] = [];
+  const P = (r: number, th: number): XY => ({ x: c.o.x + Math.cos(th) * r, y: c.o.y + Math.sin(th) * r });
+  for (let i = 0; i < n; i++) {
+    const a = c.t0 + (c.sweep * i) / n, e = c.t0 + (c.sweep * (i + 1)) / n, pts: XY[] = [], edges: Edge3[] = [];
+    // (each point with what the edge from it to the next one is)
+    const go = (p: XY, edge: Edge3) => { pts.push(p); edges.push(edge); };
+    if (i === 0 && c.start) { go(c.start.inner, 'a'); go(c.start.P, 'a'); go(c.start.outer, 'out'); } else { go(P(ri, a), 'a'); go(P(ro, a), 'out'); }
+    if (i === n - 1 && c.end) { go(c.end.outer, 'e'); go(c.end.P, 'e'); go(c.end.inner, 'in'); } else { go(P(ro, e), 'e'); go(P(ri, e), 'in'); }
+    out.push({ pts, edges, h: c.hs[i] });
+  }
+  return out;
+}
+
+/**
+ * A curved wall from its stretches: their tops, their faces inside and out (shaded round), and across them where one
+ * steps down to the next (cut away) and at an arc's ends.
+ */
+function standCurve(c: Curve3, segs: Seg3[]): PartBuilder {
+  const b = new PartBuilder('curve', c.id), n = segs.length;
+  const radial = (p: XY, k: number): V3 => { const dx = p.x - c.o.x, dy = p.y - c.o.y, L = Math.hypot(dx, dy) || 1; return [(dx / L) * k, (dy / L) * k, 0]; };
+  segs.forEach((g, i) => {
+    const h = g.h, prev = i > 0 ? segs[i - 1].h : c.arc ? 0 : segs[n - 1].h, next = i < n - 1 ? segs[i + 1].h : c.arc ? 0 : segs[0].h;
+    b.cap('top', g.pts, h);
+    for (let k = 0; k < g.pts.length; k++) {
+      const p = g.pts[k], q = g.pts[(k + 1) % g.pts.length], edge = g.edges[k], dx = q.x - p.x, dy = q.y - p.y, L = Math.hypot(dx, dy);
+      if (L < 1e-9) continue;
+      const flat: V3 = [dy / L, -dx / L, 0];
+      if (edge === 'out' || edge === 'in') {
+        const kk = edge === 'out' ? 1 : -1;
+        b.quad('wall', [p.x, p.y, 0], [q.x, q.y, 0], [q.x, q.y, h], [p.x, p.y, h], flat, [radial(p, kk), radial(q, kk), radial(q, kk), radial(p, kk)]);
+        continue;
+      }
+      const below = edge === 'a' ? prev : next;
+      if (h > below + 1e-6) b.quad('wall', [p.x, p.y, below], [q.x, q.y, below], [q.x, q.y, h], [p.x, p.y, h], flat);
+    }
+  });
+  return b;
+}
+
+/** Where two lines (a point and a direction each) cross; for parallel ones, the middle of the points if they're one line. */
+function cross(p1: XY, d1: XY, p2: XY, d2: XY): XY | null {
+  const c = d1.x * d2.y - d1.y * d2.x;
+  if (Math.abs(c) < 1e-9) return Math.abs((p2.x - p1.x) * d1.y - (p2.y - p1.y) * d1.x) < 1e-6 ? { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 } : null;
+  const l = ((p2.x - p1.x) * d2.y - (p2.y - p1.y) * d2.x) / c;
+  return { x: p1.x + d1.x * l, y: p1.y + d1.y * l };
+}
+
+/** What meets at a joint: a wall's end (`key`), the way it runs away from the joint, and how thick it is. */
+interface End3 { key: string; u: XY; t: number }
+
+/**
+ * Where the sides of what meets at P cross, as model/wallshape.ts works it out for straight walls: each end's corners,
+ * left and right as seen going away from P; and a bevel where two meet so sharply the corner would run far out.
+ */
+function jointCorners(P: XY, list: End3[]): { corners: Map<string, { l: XY; r: XY }>; bevels: { pts: XY[]; keys: [string, string] }[] } {
+  const at = (p: XY, n: XY, k: number): XY => ({ x: p.x + n.x * k, y: p.y + n.y * k });
+  const sorted = [...list].sort((p, q) => Math.atan2(p.u.y, p.u.x) - Math.atan2(q.u.y, q.u.x)), n = sorted.length;
+  const ccw = new Map<number, XY>(), cw = new Map<number, XY>(), bevels: { pts: XY[]; keys: [string, string] }[] = [];
+  for (let i = 0; i < n; i++) {
+    const a = sorted[i], b = sorted[(i + 1) % n];
+    const ea = at(P, { x: -a.u.y, y: a.u.x }, a.t / 2), eb = at(P, { x: b.u.y, y: -b.u.x }, b.t / 2);
+    const c = cross(ea, a.u, eb, b.u);
+    if (c && hyp(c.x - P.x, c.y - P.y) <= 2 * Math.max(a.t, b.t)) { ccw.set(i, c); cw.set((i + 1) % n, c); continue; }
+    ccw.set(i, ea); cw.set((i + 1) % n, eb);
+    if (hyp(ea.x - eb.x, ea.y - eb.y) > 1e-6) bevels.push({ pts: [P, ea, eb], keys: [a.key, b.key] });
+  }
+  const corners = new Map<string, { l: XY; r: XY }>();
+  sorted.forEach((e, i) => corners.set(e.key, { l: ccw.get(i)!, r: cw.get(i)! }));
+  return { corners, bevels };
+}
+
+/**
+ * A straight wall's outline as model/wallshape.ts gives it, read back into its ends' corners (left and right as seen
+ * going away from each end) and whether each end runs to its point (a joint).
+ */
+function outlineEnds(pts: XY[], jointA: boolean, jointB: boolean): { a: { l: XY; r: XY; joint: boolean }; b: { l: XY; r: XY; joint: boolean } } {
+  const k = jointB ? 3 : 2;
+  return { a: { r: pts[0], l: pts[k + 1], joint: jointA }, b: { l: pts[1], r: pts[k], joint: jointB } };
+}
+
+export interface Build3Opts {
+  /** cut away the walls in front (null: every wall at its full height) */
+  cut?: Cut3 | null;
+}
+
+/**
+ * The 3D view of plan `sk`. (With the plan's lines indexed for it: each space asks which lines join its corners, and
+ * scanning every line for each made the build cost the square of the plan.)
+ */
+export function buildScene(sk: Sketch, opts: Build3Opts = {}): Scene3 {
+  return withLineIndex(sk, () => build(sk, opts));
+}
+
+function build(sk: Sketch, opts: Build3Opts): Scene3 {
+  const cut = opts.cut ?? null, lowered: string[] = [], parts: Part3[] = [];
+  const walls = straightWalls(sk, cut, lowered), curves = curvedWalls(sk, cut, lowered);
+  const wallParts = new Map<string, PartBuilder>();
+  const partOf = (id: string) => {
+    let b = wallParts.get(id);
+    if (!b) wallParts.set(id, (b = new PartBuilder('wall', id)));
+    return b;
+  };
+
+  // what meets at each point: the straight walls with an end there, and whether a curved one ends there too
+  const ends = new Map<string, string[]>(), curvedEnd = new Set<string>();
+  for (const [id, l] of Object.entries(sk.lines)) {
+    if (!walls.has(id)) continue;
+    for (const p of [l.a, l.b]) (ends.get(p) ?? ends.set(p, []).get(p)!).push(id);
+  }
+  for (const a of Object.values(sk.arcs)) if (a.kind === 'wall' && !a.constr) { curvedEnd.add(a.a); curvedEnd.add(a.b); }
+
+  const pieces = wallPieces(sk, w => !w.constr), outline = new Map<string, XY[]>();
+  for (const pc of pieces) if (pc.id && walls.has(pc.id)) outline.set(pc.id, tidy(pc.pts));
+
+  // where straight walls meet a curved wall's end: cut on a mitre, as two straight walls meet (the curve taken as the
+  // line it leaves its end along) — not run on into it, which left slivers and a cluster of edges
+  const curveEnds = new Map<string, { c: Curve3; start: boolean }[]>();
+  for (const c of curves) for (const [pid, start] of [[c.pa, true], [c.pb, false]] as const) if (pid) (curveEnds.get(pid) ?? curveEnds.set(pid, []).get(pid)!).push({ c, start });
+  const jointAt = (pid: string) => (ends.get(pid)?.length ?? 0) > 1 && !curvedEnd.has(pid);
+  type JointEnd = End3 & { h: number; wall?: Wall3; curve?: Curve3; start?: boolean };
+  const curveJoints: { P: XY; list: JointEnd[] }[] = [];
+  const curveBevels: { pts: XY[]; owner: string; curve: boolean; h: number }[] = [];
+  for (const [pid, onCurve] of curveEnds) {
+    const P = sk.points[pid], straight = (ends.get(pid) ?? []).map(id => walls.get(id)!);
+    if (!P || straight.length + onCurve.length < 2) continue;
+    const list: JointEnd[] = [
+      ...straight.map(w => ({ key: w.id, u: near(w.A, P) ? w.u : { x: -w.u.x, y: -w.u.y }, t: w.t, h: w.h, wall: w })),
+      ...onCurve.map(({ c, start }) => {
+        const th = start ? c.t0 : c.t0 + c.sweep;
+        return { key: c.id + (start ? '>' : '<'), u: start ? { x: -Math.sin(th), y: Math.cos(th) } : { x: Math.sin(th), y: -Math.cos(th) }, t: c.t, h: c.hs[start ? 0 : c.hs.length - 1], curve: c, start };
+      }),
+    ];
+    // (a straight wall running on smoothly into the curve already meets its square end)
+    if (list.length === 2 && Math.abs(list[0].u.x * list[1].u.y - list[0].u.y * list[1].u.x) < 0.02 && list[0].u.x * list[1].u.x + list[0].u.y * list[1].u.y < 0) continue;
+    const { corners, bevels } = jointCorners(P, list);
+    for (const w of straight) {
+      const l = sk.lines[w.id], pc = pieces.find(q => q.id === w.id);
+      if (!pc) continue;
+      const e = outlineEnds(pc.pts, jointAt(l.a), jointAt(l.b)), k = corners.get(w.id)!;
+      if (l.a === pid) e.a = { ...k, joint: true }; else e.b = { ...k, joint: true };
+      pc.pts = [e.a.r, e.b.l, ...(e.b.joint ? [w.B] : []), e.b.r, e.a.l, ...(e.a.joint ? [w.A] : [])];
+      outline.set(w.id, tidy(pc.pts));
+    }
+    for (const { c, start } of onCurve) {
+      const k = corners.get(c.id + (start ? '>' : '<'))!;
+      // (going away from its start along the curve, its left is the inside; away from its end, the outside)
+      if (start) c.start = { P, inner: k.l, outer: k.r }; else c.end = { P, inner: k.r, outer: k.l };
+    }
+    for (const bv of bevels) {
+      const owner = list.find(x => x.key === bv.keys[0] && x.wall) ?? list.find(x => x.key === bv.keys[1] && x.wall) ?? list.find(x => x.key === bv.keys[0])!;
+      curveBevels.push({ pts: bv.pts, owner: owner.wall ? owner.wall.id : owner.curve!.id, curve: !owner.wall, h: Math.max(...list.filter(x => bv.keys.includes(x.key)).map(x => x.h)) });
+    }
+    curveJoints.push({ P, list });
+  }
+
+  // a wall ending on the middle of another (a T) stops at that wall's face; where it's the taller, it runs on over it
+  const over: { stub: Wall3; at: Wall3; P: XY }[] = [];
+  for (const [pid, ids] of ends) {
+    if (ids.length !== 1 || curvedEnd.has(pid)) continue;
+    const P = sk.points[pid], stub = walls.get(ids[0])!;
+    for (const w of walls.values()) {
+      if (w.id === stub.id || !sideways(stub.u, w.u)) continue;
+      const s = (P.x - w.A.x) * w.u.x + (P.y - w.A.y) * w.u.y, off = (P.x - w.A.x) * -w.u.y + (P.y - w.A.y) * w.u.x;
+      if (s <= 0.5 || s >= w.L - 0.5 || Math.abs(off) > Math.max(0.5, w.t / 4)) continue;
+      const poly = outline.get(stub.id);
+      if (poly) {
+        // keep the stub's side of the wall's near face
+        const far = near(stub.A, P) ? stub.B : stub.A, nx = -w.u.y, ny = w.u.x;
+        const k = Math.sign((far.x - P.x) * nx + (far.y - P.y) * ny) || 1;
+        const trimmed = tidy(clipHalf(poly, -k * nx, -k * ny, -k * (nx * P.x + ny * P.y) - w.t / 2));
+        if (trimmed.length >= 3) outline.set(stub.id, trimmed);
+      }
+      if (stub.h > w.h + 1e-6) over.push({ stub, at: w, P });
+      break;
+    }
+  }
+
+  // the walls, with their doors and windows; each wall's cells for the outlines, and the lines round its windows' glass
+  const cellsOf = new Map<string, Cell3[]>(), lines: number[] = [], byWall = openingsByWall(sk);
+  const raise = (id: string, o: XY, u: XY, half: number, top: number) => cellsOf.set(id, (cellsOf.get(id) ?? []).flatMap(c => raiseIn(c, o, u, half, top)));
+  for (const w of walls.values()) {
+    const poly = outline.get(w.id);
+    if (!poly) continue;
+    const ops = openingsIn(sk, w, byWall.get(w.id) ?? []);
+    standWall(partOf(w.id), w, poly, ops);
+    cellsOf.set(w.id, wallCells(w, poly, ops));
+    for (const o of ops) {
+      const p = openingPart(w, o);
+      if (p) parts.push(p);
+      if (o.type === 'door' && o.head > 1) parts.push(doorPart(w, o, lines));
+      if (o.type === 'window' && o.head - o.sill > 0.01) {
+        const a = { x: w.A.x + w.u.x * o.s0, y: w.A.y + w.u.y * o.s0 }, c = { x: w.A.x + w.u.x * o.s1, y: w.A.y + w.u.y * o.s1 };
+        lines.push(a.x, a.y, o.sill, c.x, c.y, o.sill, c.x, c.y, o.sill, c.x, c.y, o.head, c.x, c.y, o.head, a.x, a.y, o.head, a.x, a.y, o.head, a.x, a.y, o.sill);
+      }
+    }
+  }
+  // a sharp corner's bevel: as tall as the tallest wall there
+  for (const pc of pieces) {
+    if (pc.id || !walls.has(pc.of)) continue;
+    const P = pc.pts[0], h = Math.max(...[...walls.values()].filter(w => near(w.A, P) || near(w.B, P)).map(w => w.h), walls.get(pc.of)!.h);
+    partOf(pc.of).prism(tidy(pc.pts), 0, h, 'wall', 'top');
+    cellsOf.get(pc.of)?.push({ poly: tidy(pc.pts), iv: [[0, h]] });
+  }
+  // where walls meet, the joint goes up to the tallest of them: a shorter wall's share of the corner, inside the
+  // taller one's thickness, rises with the taller (walls in line just step)
+  for (const [pid, ids] of ends) {
+    if (ids.length < 2 || curvedEnd.has(pid)) continue;
+    const P = sk.points[pid];
+    for (const lo of ids) {
+      const a = walls.get(lo)!, poly = outline.get(lo);
+      if (!poly) continue;
+      // the tallest first; two walls in line through the joint share one band, so it rises once, with the taller
+      const taller = ids.map(id => walls.get(id)!).filter(b => b.h > a.h + 1e-6 && sideways(a.u, b.u)).sort((p, q) => q.h - p.h);
+      const raised: XY[][] = [];
+      for (const b of taller) {
+        raise(lo, P, b.u, b.t / 2, b.h);
+        const share = tidy(clipBand(poly, P, b.u, b.t / 2));
+        if (share.length < 3 || area(share) <= 1e-4 || raised.some(r => samePoly(r, share))) continue;
+        raised.push(share);
+        partOf(b.id).prism(share, a.h, b.h, 'wall', 'top');
+      }
+    }
+  }
+  for (const { stub, at: w, P } of over) {
+    // across the whole thickness of the wall it meets, as wide as the stub
+    const R = 4 * (stub.t + w.t), sq = [{ x: P.x - R, y: P.y - R }, { x: P.x + R, y: P.y - R }, { x: P.x + R, y: P.y + R }, { x: P.x - R, y: P.y + R }];
+    const cross = tidy(clipBand(clipBand(sq, P, stub.u, stub.t / 2), P, w.u, w.t / 2));
+    if (cross.length >= 3) partOf(stub.id).prism(cross, w.h, stub.h, 'wall', 'top');
+    raise(w.id, P, stub.u, stub.t / 2, stub.h);
+  }
+  // the curved walls, by their stretches
+  const curveParts = new Map<string, PartBuilder>(), segsOf = new Map<string, Seg3[]>();
+  for (const c of curves) {
+    const segs = curveSegments(c);
+    segsOf.set(c.id, segs);
+    curveParts.set(c.id, standCurve(c, segs));
+    cellsOf.set(c.id, segs.map(g => ({ poly: g.pts, iv: [[0, g.h]] as [number, number][] })));
+  }
+  // a sharp joint's bevel at a curved wall's end, as tall as the taller of the two
+  for (const bv of curveBevels) {
+    const poly = tidy(bv.pts);
+    (bv.curve ? curveParts.get(bv.owner)! : partOf(bv.owner)).prism(poly, 0, bv.h, 'wall', 'top');
+    cellsOf.get(bv.owner)?.push({ poly, iv: [[0, bv.h]] });
+  }
+  // and where they meet straight walls of another height: the joint goes up to the taller, as at any joint
+  for (const { P, list } of curveJoints) {
+    for (const lo of list) {
+      const own = lo.wall ? outline.get(lo.wall.id) : segsOf.get(lo.curve!.id)?.[lo.start ? 0 : segsOf.get(lo.curve!.id)!.length - 1].pts;
+      if (!own) continue;
+      for (const hi of list) {
+        if (hi === lo || hi.h <= lo.h + 1e-6 || !sideways(lo.u, hi.u)) continue;
+        const share = tidy(clipBand(own, P, hi.u, hi.t / 2));
+        if (share.length < 3 || area(share) <= 1e-4) continue;
+        (hi.wall ? partOf(hi.wall.id) : curveParts.get(hi.curve!.id)!).prism(share, lo.h, hi.h, 'wall', 'top');
+        raise(lo.wall ? lo.wall.id : lo.curve!.id, P, hi.u, hi.t / 2, hi.h);
+      }
+    }
+  }
+  for (const b of wallParts.values()) if (!b.empty) parts.unshift(b);
+  for (const b of curveParts.values()) parts.push(b);
+  for (const v of cellLines([...cellsOf.values()].flat())) lines.push(v);
+
+  // each space's floor, to the inside faces of its walls
+  for (const [rid, r] of Object.entries(sk.rooms)) {
+    if (!roomValid(sk, r)) continue;
+    const poly = tidy(roomGeom(sk, r).inner);
+    if (poly.length < 3 || area(poly) < 1) continue;
+    const b = new PartBuilder('floor', rid);
+    b.cap('floor', poly, 0);
+    if (!b.empty) parts.push(b);
+  }
+
+  // the cabinets on each wall face: out from the face by their depth; a base cabinet's top is its counter
+  for (const [key, face] of Object.entries(sk.faces ?? {})) {
+    if (!face.cabs || !Object.keys(face.cabs).length) continue;
+    const { lid, side } = faceKeyParts(key), f = faceFrame(sk, lid, side), w = walls.get(lid);
+    if (!f || !w) continue;
+    const nx = -f.uy * f.side, ny = f.ux * f.side;
+    const P = (s: number, k: number): XY => ({ x: f.A.x + f.ux * s + nx * k, y: f.A.y + f.uy * s + ny * k });
+    for (const [cid, cb] of Object.entries(face.cabs)) {
+      const ps = [cb.bl, cb.br, cb.tr, cb.tl].map(p => face.points[p]);
+      if (ps.some(p => !p)) continue;
+      const sa = toU(f, Math.min(...ps.map(p => p.x))), sb = toU(f, Math.max(...ps.map(p => p.x)));
+      const s0 = Math.min(sa, sb), s1 = Math.max(sa, sb), z0 = Math.max(0, Math.min(...ps.map(p => p.y))), z1 = Math.max(...ps.map(p => p.y));
+      if (s1 - s0 < 0.1 || z1 - z0 < 0.1) continue;
+      // (hung above a wall that's cut away: it goes with the wall)
+      if (w.h < w.full && z0 >= w.h - 1e-6) continue;
+      const poly = tidy([P(s0, f.t / 2), P(s1, f.t / 2), P(s1, f.t / 2 + cb.depth), P(s0, f.t / 2 + cb.depth)]);
+      const b = new PartBuilder('cab', key + '#' + cid), base = z0 < UPPER_Z && z1 - z0 > 4 * COUNTER;
+      if (base) {
+        b.prism(poly, z0, z1 - COUNTER, 'cab', null);
+        b.prism(poly, z1 - COUNTER, z1, 'counter', 'counter', null);
+      } else b.prism(poly, z0, z1, 'cab', 'cab');
+      parts.push(b);
+      for (const v of boxLines(poly, z0, z1, base ? [z1 - COUNTER] : [])) lines.push(v);
+    }
+  }
+
+  const min: V3 = [Infinity, Infinity, Infinity], max: V3 = [-Infinity, -Infinity, -Infinity];
+  for (const p of parts) {
+    for (let i = 0; i < p.pos.length; i += 3) {
+      for (let k = 0; k < 3; k++) {
+        const v = p.pos[i + k];
+        if (v < min[k]) min[k] = v;
+        if (v > max[k]) max[k] = v;
+      }
+    }
+  }
+  if (!isFinite(min[0])) return { parts, min: [0, 0, 0], max: [0, 0, 0], lowered, lines };
+  return { parts, min, max, lowered, lines };
+}