@a2f0/skyline 0.0.0-stage → 0.1.2

package/lib/models/crain-tower.js

@@ -0,0 +1,378 @@
+import * as THREE from "../vendor/three-r186.js";
+import { createBuilder, inside, line } from "./building-kit.js";
+// The curtain wall's rhythm. The drawing and the photograph both give a 3.5 m band pitch,
+// so the 41 published floors, above a taller lobby, fit under the 152.5 m main roof. Each
+// floor is a ribbon of glass between sill and head, with white spandrels covering the slab.
+export const crainFloors = Object.freeze({
+    lobbyTop: 7.0,
+    pitch: 3.5,
+    sill: 0.9,
+    head: 2.55,
+    module: 1.524,
+    lobbyGlass: [0.45, 5.9],
+});
+export const crainMainRoof = 152.5;
+const orient = (corners) => {
+    const area = corners.reduce((sum, [x, z], i) => { const [x2, z2] = corners[(i + 1) % corners.length]; return sum + x * z2 - x2 * z; }, 0);
+    return area < 0 ? corners : [...corners].reverse();
+};
+const planOf = (corners) => corners.map((corner, i) => line(corner, corners[(i + 1) % corners.length]));
+// The ribbon glazing's tones: mostly dark reflective glass, with a few lit and dim panes.
+const paneTones = [0x232323, 0x2a2a2a, 0x303030, 0x1f1f1f].map((hex) => new THREE.Color(hex));
+const litPane = new THREE.Color(0x8a8a8a), dimPane = new THREE.Color(0x565656), mullionTone = new THREE.Color(0x585858);
+function paneColor(row, module, wall) {
+    const hash = (Math.imul(row + 29, 0x9e3779b1) ^ Math.imul(module + 41, 0x85ebca77) ^ Math.imul(wall + 13, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 97;
+    if (value < 3)
+        return litPane;
+    if (value < 6)
+        return dimPane;
+    return paneTones[value % paneTones.length];
+}
+// A plane's upward normal from a height function sampled around a point.
+function slopeNormal(roof, [x, z]) {
+    const dx = roof([x + 1, z]) - roof([x, z]), dz = roof([x, z + 1]) - roof([x, z]);
+    const length = Math.hypot(dx, 1, dz);
+    return [-dx / length, 1 / length, -dz / length];
+}
+function faceNormal(a, b, c) {
+    const u = [b[0] - a[0], b[1] - a[1], b[2] - a[2]], v = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+    const n = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]];
+    const length = Math.hypot(...n);
+    return [n[0] / length, n[1] / length, n[2] / length];
+}
+// Where a line crosses a polygon, as the parameter intervals that lie inside it.
+function clipLine(polygon, origin, direction) {
+    const hits = [];
+    for (let i = 0; i < polygon.length; i += 1) {
+        const a = polygon[i], b = polygon[(i + 1) % polygon.length];
+        const e = [b[0] - a[0], b[1] - a[1]];
+        const denominator = direction[0] * e[1] - direction[1] * e[0];
+        if (Math.abs(denominator) < 1e-12)
+            continue;
+        const w = [a[0] - origin[0], a[1] - origin[1]];
+        const t = (w[0] * e[1] - w[1] * e[0]) / denominator, u = (w[0] * direction[1] - w[1] * direction[0]) / denominator;
+        if (u >= 0 && u < 1)
+            hits.push(t);
+    }
+    hits.sort((p, q) => p - q);
+    const spans = [];
+    for (let i = 0; i + 1 < hits.length; i += 2)
+        spans.push([hits[i], hits[i + 1]]);
+    return spans;
+}
+export function buildCrainTower(form) {
+    const kit = createBuilder(form.name, form.id);
+    const shell = kit.batch("Crain · aluminum spandrels", kit.material(0xc4c4c4));
+    const ribbons = kit.batch("Crain · ribbon glazing", kit.material(0xffffff, { vertexColors: true }));
+    const glazing = kit.batch("Crain · sloped glazing", kit.material(0x333333));
+    const grid = kit.batch("Crain · glazing grid", kit.material(0x727272));
+    const lights = kit.batch("Crain · diamond outline lights", kit.material(0xf0f0f0));
+    const coping = kit.batch("Crain · coping", kit.material(0x5c5c5c));
+    const deck = kit.batch("Crain · slot floor", kit.material(0x4a4a4a));
+    const vents = form.crown ? kit.batch("Crain · mechanical louvers", kit.material(0xffffff, { vertexColors: true })) : ribbons;
+    const blades = form.crown ? kit.batch("Crain · louver blades", kit.material(0xffffff, { vertexColors: true })) : ribbons;
+    const shadowStrips = form.crown ? kit.batch("Crain · crown shadow strips", kit.material(0xffffff, { vertexColors: true })) : ribbons;
+    const ventTone = new THREE.Color(0x303030), bladeTone = new THREE.Color(0x696969), shadowTone = new THREE.Color(0x252525);
+    const base = form.base;
+    const volumes = form.volumes.map((volume) => {
+        const corners = orient(volume.corners);
+        return { ...volume, corners, plan: planOf(corners) };
+    });
+    // Model height from a real height.
+    const y = (real) => real - base;
+    // A slab of the plan lifted onto a plane `drop` below the roof. kit.slab lays a flat
+    // polygon; lifting its vertices keeps each triangle planar, and its winding still faces
+    // the way it was laid, so the normal follows the plane, flipped for a downward face.
+    const liftedSlab = (target, corners, roof, drop, up) => {
+        const start = target.positions.length;
+        kit.slab(target, corners, 0, up);
+        const n = slopeNormal(roof, corners[0]), normal = up ? n : [-n[0], -n[1], -n[2]];
+        for (let i = start; i < target.positions.length; i += 3) {
+            target.positions[i + 1] = y(roof([target.positions[i], target.positions[i + 2]]) - drop);
+            target.normals.splice(i, 3, ...normal);
+        }
+    };
+    // The masses: walls, a floor, and a lid a skin's depth under the roof, closed within the
+    // spandrels' mesh. The roof itself is a thin closed slab on the lid, glass on the halves
+    // and a deck on the slot's floor, so it stays the building's top. Neighbouring volumes
+    // keep their own walls on shared edges, facing opposite ways.
+    const skin = 0.05;
+    for (const volume of volumes) {
+        const { corners, plan, roof } = volume;
+        const top = volume.glazed ? glazing : deck;
+        for (const run of plan) {
+            const a = run.at(0), b = run.at(run.length), n = run.normal(0), normal = [n[0], 0, n[1]];
+            kit.quad(shell, [[a[0], 0, a[1]], [b[0], 0, b[1]], [b[0], y(roof(b) - skin), b[1]], [a[0], y(roof(a) - skin), a[1]]], [normal]);
+            kit.quad(top, [[a[0], y(roof(a) - skin), a[1]], [b[0], y(roof(b) - skin), b[1]], [b[0], y(roof(b)), b[1]], [a[0], y(roof(a)), a[1]]], [normal]);
+        }
+        kit.slab(shell, corners, 0, false);
+        liftedSlab(shell, corners, roof, skin, true);
+        liftedSlab(top, corners, roof, skin, false);
+        liftedSlab(top, corners, roof, 0, true);
+    }
+    // A wall is exposed where no neighbour stands against it, and a neighbour's roof covers
+    // it up to that roof's height. Probing just outside the wall splits a run into stretches,
+    // each facing open air or one neighbour, so a plan needs no corner where that changes.
+    const neighbourAt = (self, run, s) => volumes.findIndex((volume, index) => index !== self && inside(volume.corners, run.at(s, 0.3)));
+    const stretches = (self, run) => {
+        const out = [];
+        let start = 0, current = neighbourAt(self, run, Math.min(0.05, run.length / 2));
+        for (let s = 0.25; s < run.length - 0.05; s += 0.25) {
+            if (neighbourAt(self, run, s) === current)
+                continue;
+            let low = s - 0.25, high = s;
+            for (let i = 0; i < 30; i += 1) {
+                const middle = (low + high) / 2;
+                if (neighbourAt(self, run, middle) === current)
+                    low = middle;
+                else
+                    high = middle;
+            }
+            out.push({ from: start, to: high, neighbour: current });
+            start = high;
+            current = neighbourAt(self, run, s);
+        }
+        out.push({ from: start, to: run.length, neighbour: current });
+        // Near an acute corner the probe can land outside the neighbour for a few centimetres;
+        // no real change of neighbour comes that close to a corner, so a short stretch joins
+        // the longer one beside it.
+        for (let i = out.findIndex((piece) => piece.to - piece.from < 0.6); out.length > 1 && i >= 0; i = out.findIndex((piece) => piece.to - piece.from < 0.6)) {
+            const piece = out[i], before = out[i - 1], after = out[i + 1];
+            const into = !after || (before && before.to - before.from >= after.to - after.from) ? before : after;
+            into.from = Math.min(into.from, piece.from);
+            into.to = Math.max(into.to, piece.to);
+            out.splice(i, 1);
+        }
+        return out;
+    };
+    // A closed box on a run between two heights that each vary linearly along it. Its front is
+    // cut into panes and mullions on the curtain wall's module, counted from the run's start so
+    // mullions line up from floor to floor.
+    const strip = (run, from, to, b0, b1, t0, t1, row, wall, surface) => {
+        const target = surface === "glass" ? ribbons : surface === "vent" ? vents : surface === "blade" ? blades : shadowStrips;
+        const back = surface === "blade" ? 0.045 : 0.02, front = surface === "blade" ? 0.13 : 0.08;
+        const n = run.normal(0), tangent = [n[1], -n[0]];
+        const at = (s, depth, h) => { const p = run.at(s, depth); return [p[0], y(h), p[1]]; };
+        const bottom = (s) => b0 + (b1 - b0) * (s - from) / (to - from), top = (s) => t0 + (t1 - t0) * (s - from) / (to - from);
+        const outward = [n[0], 0, n[1]];
+        const cuts = [from];
+        const module = crainFloors.module, half = 0.035;
+        if (surface !== "blade")
+            for (let k = Math.ceil((from + half) / module); k * module < to - half; k += 1)
+                cuts.push(k * module - half, k * module + half);
+        cuts.push(to);
+        for (let i = 0; i + 1 < cuts.length; i += 1) {
+            const sa = cuts[i], sb = cuts[i + 1];
+            if (sb - sa < 1e-6)
+                continue;
+            const mullion = i % 2 === 1;
+            const color = mullion ? mullionTone : surface === "glass" ? paneColor(row, Math.floor((sa + sb) / 2 / module), wall)
+                : surface === "vent" ? ventTone : surface === "blade" ? bladeTone : shadowTone;
+            kit.quad(target, [at(sa, front, bottom(sa)), at(sb, front, bottom(sb)), at(sb, front, top(sb)), at(sa, front, top(sa))], [outward], color);
+        }
+        const dark = paneTones[0];
+        kit.quad(target, [at(to, back, b1), at(from, back, b0), at(from, back, t0), at(to, back, t1)], [[-n[0], 0, -n[1]]], dark);
+        // The top and bottom fan out from a back corner through every cut on the front, so each
+        // pane's edge meets its partner and the strip closes without T-junctions.
+        const ends = cuts.filter((s, i) => i === 0 || s - cuts[i - 1] >= 1e-6);
+        const fan = (height, h0, h1, up) => {
+            const hinge = at(from, back, h0), front0 = at(from, front, h0);
+            const normal = faceNormal(hinge, at(to, back, h1), front0);
+            const facing = (normal[1] > 0) === up ? normal : [-normal[0], -normal[1], -normal[2]];
+            for (let i = 0; i + 1 < ends.length; i += 1)
+                kit.triangle(target, [hinge, at(ends[i], front, height(ends[i])), at(ends[i + 1], front, height(ends[i + 1]))], [facing, facing, facing], dark);
+            kit.triangle(target, [hinge, at(to, front, h1), at(to, back, h1)], [facing, facing, facing], dark);
+        };
+        fan(top, t0, t1, true);
+        fan(bottom, b0, b1, false);
+        kit.quad(target, [at(from, front, b0), at(from, back, b0), at(from, back, t0), at(from, front, t0)], [[-tangent[0], 0, -tangent[1]]], dark);
+        kit.quad(target, [at(to, back, b1), at(to, front, b1), at(to, front, t1), at(to, back, t1)], [[tangent[0], 0, tangent[1]]], dark);
+    };
+    // Ribbons stop this far under the roof edge, below the deepest fascia hung there, so the
+    // two never meet in one plane where a traced wall splits into collinear pieces.
+    const underRoof = 0.8;
+    // One ribbon on one wall: between the band's sill and head, under the roof, and above any
+    // neighbour. The bounds are linear along the run, so splitting it where one bound overtakes
+    // another leaves pieces whose bottom and top are each a single linear function.
+    const ribbon = (run, clear, roof, cover, g0, g1, row, wall, surface = "glass") => {
+        const least = 0.05;
+        const from = clear[0], to = run.length - clear[1];
+        if (to - from < 0.3)
+            return;
+        const low = (s) => Math.max(g0, cover ? cover(s) + 0.2 : -Infinity, base);
+        const high = (s) => Math.min(g1, roof(s) - underRoof);
+        // Each bound is the larger or smaller of linear pieces; split where they trade places.
+        const trades = [(s) => roof(s) - underRoof - g1];
+        if (cover)
+            trades.push((s) => cover(s) + 0.2 - g0, (s) => cover(s) + 0.2 - base);
+        const breaks = [from, to];
+        for (const f of trades) {
+            const fa = f(from), fb = f(to);
+            if ((fa > 0) !== (fb > 0))
+                breaks.push(from + (to - from) * fa / (fa - fb));
+        }
+        breaks.sort((p, q) => p - q);
+        for (let i = 0; i + 1 < breaks.length; i += 1) {
+            let sa = breaks[i], sb = breaks[i + 1];
+            // Within a piece the ribbon's height is linear. Where the roof or a neighbour pinches
+            // it off, end the piece where it is still `least` tall rather than at a knife edge.
+            const ha = high(sa) - low(sa), hb = high(sb) - low(sb);
+            if (ha < least && hb < least)
+                continue;
+            if (ha < least)
+                sa += (sb - sa) * (least - ha) / (hb - ha);
+            else if (hb < least)
+                sb -= (sb - sa) * (least - hb) / (ha - hb);
+            if (sb - sa < 0.12)
+                continue;
+            strip(run, sa, sb, low(sa), low(sb), high(sa), high(sb), row, wall, surface);
+        }
+    };
+    // A fascia hung on a wall just under its roof edge: its top follows the edge, flush with
+    // the roof, and it stands out from the wall rather than over the roof, so it never shares
+    // the roof's plane and the roof stays the building's top. At a convex corner it runs on by
+    // its own width to close the corner with its neighbour.
+    const fascia = (target, run, roof, width, drop, extend) => {
+        const s0 = -extend[0], s1 = run.length + extend[1], n = run.normal(0), tangent = [n[1], -n[0]];
+        const at = (s, depth, lower) => { const p = run.at(s, depth); return [p[0], y(roof(run.at(s)) - lower), p[1]]; };
+        const T = [at(s0, 0, 0), at(s0, width, 0), at(s1, width, 0), at(s1, 0, 0)];
+        const b = [at(s0, 0, drop), at(s1, 0, drop), at(s1, width, drop), at(s0, width, drop)];
+        kit.quad(target, T, [faceNormal(T[0], T[1], T[2])]);
+        kit.quad(target, b, [faceNormal(b[0], b[1], b[2])]);
+        kit.quad(target, [at(s0, width, drop), at(s1, width, drop), at(s1, width, 0), at(s0, width, 0)], [[n[0], 0, n[1]]]);
+        kit.quad(target, [at(s1, 0, drop), at(s0, 0, drop), at(s0, 0, 0), at(s1, 0, 0)], [[-n[0], 0, -n[1]]]);
+        kit.quad(target, [at(s0, 0, drop), at(s0, width, drop), at(s0, width, 0), at(s0, 0, 0)], [[-tangent[0], 0, -tangent[1]]]);
+        kit.quad(target, [at(s1, width, drop), at(s1, 0, drop), at(s1, 0, 0), at(s1, width, 0)], [[tangent[0], 0, tangent[1]]]);
+    };
+    // A slim bar on a roof between two plan points, for the glazing grid. Every corner sits a
+    // fixed height off the roof plane, so its top and bottom lie parallel to the glass across
+    // its width as well as along it.
+    const roofBox = (target, p0, p1, roof, halfWidth, lift, drop) => {
+        const chord = Math.hypot(p1[0] - p0[0], p1[1] - p0[1]);
+        const t = [(p1[0] - p0[0]) / chord, (p1[1] - p0[1]) / chord], n = [-t[1], t[0]];
+        const corner = (end, across, offset) => {
+            const at = [end[0] + n[0] * across, end[1] + n[1] * across];
+            return [at[0], y(roof(at) + offset), at[1]];
+        };
+        const b = [corner(p0, -halfWidth, -drop), corner(p0, halfWidth, -drop), corner(p1, halfWidth, -drop), corner(p1, -halfWidth, -drop)];
+        const T = [corner(p0, -halfWidth, lift), corner(p0, halfWidth, lift), corner(p1, halfWidth, lift), corner(p1, -halfWidth, lift)];
+        kit.quad(target, [T[0], T[1], T[2], T[3]], [faceNormal(T[0], T[1], T[2])]);
+        kit.quad(target, [b[0], b[3], b[2], b[1]], [faceNormal(b[0], b[3], b[2])]);
+        for (const i of [0, 1, 2, 3]) {
+            const j = (i + 1) % 4;
+            kit.quad(target, [T[j], T[i], b[i], b[j]], [faceNormal(T[j], T[i], b[i])]);
+        }
+    };
+    // How a run meets its neighbour at each end: the signed angle between their outward
+    // normals, negative at a convex corner, positive at a concave one, and near zero where a
+    // traced outline splits one wall into nearly collinear pieces.
+    const straight = 5 * Math.PI / 180;
+    const turns = (plan, index) => {
+        const turn = (a, b) => { const n1 = a.normal(a.length), n2 = b.normal(0); return Math.atan2(n1[0] * n2[1] - n1[1] * n2[0], n1[0] * n2[0] + n1[1] * n2[1]); };
+        const count = plan.length, run = plan[index];
+        return [turn(plan[(index + count - 1) % count], run), turn(run, plan[(index + 1) % count])];
+    };
+    // Two walls' ribbons stand out 0.08 m and cross within this distance of their corner; the
+    // sharper the turn, the further, so a ribbon stops that far short of it. Across a nearly
+    // straight joint a 2 mm gap is enough, and keeps their level sills and heads from
+    // overlapping in the same plane.
+    const cornerClearance = (turn) => 0.08 * Math.tan(Math.abs(turn) / 2) + (Math.abs(turn) < straight ? 0.002 : 0.025);
+    let wall = 0;
+    volumes.forEach((volume, self) => {
+        volume.plan.forEach((whole, index) => {
+            const [startTurn, endTurn] = turns(volume.plan, index);
+            stretches(self, whole).forEach(({ from, to, neighbour }, piece, all) => {
+                wall += 1;
+                // A stretch is its own run, so everything below measures along it; a whole run keeps
+                // its mullions counted from its own start.
+                const run = from === 0 && to === whole.length ? whole : line(whole.at(from), whole.at(to));
+                const covering = neighbour < 0 ? null : volumes[neighbour];
+                const cover = covering ? (s) => covering.roof(run.at(s)) : null;
+                const roof = (s) => volume.roof(run.at(s));
+                // Ribbons run on across a straight joint and stop short of a corner, so the two walls'
+                // ribbons never overlap there.
+                const first = piece === 0, last = piece === all.length - 1;
+                const clear = [cornerClearance(first ? startTurn : 0), cornerClearance(last ? endTurn : 0)];
+                const n = run.normal(0), outer = Math.max(Math.abs(n[0]), Math.abs(n[1])) > 0.95;
+                const crown = volume.glazed && outer ? form.crown : undefined;
+                // Ribbons: the lobby's tall storefront, then one per floor up to the roof.
+                ribbon(run, clear, roof, cover, crainFloors.lobbyGlass[0], crainFloors.lobbyGlass[1], 0, wall);
+                const peak = Math.max(roof(0), roof(run.length));
+                for (let row = 1; crainFloors.lobbyTop + (row - 1) * crainFloors.pitch + crainFloors.sill < peak; row += 1) {
+                    const level = crainFloors.lobbyTop + (row - 1) * crainFloors.pitch;
+                    if (crown && level + crainFloors.head > crown.officeTop)
+                        continue;
+                    ribbon(run, clear, roof, cover, level + crainFloors.sill, level + crainFloors.head, row, wall);
+                }
+                if (crown) {
+                    for (const [lo, hi] of crown.louvers) {
+                        ribbon(run, clear, roof, cover, lo, hi, 0, wall, "vent");
+                        // Slim closed blades seated in the dark backing. Extra end clearance
+                        // accommodates their 5 cm relief at corners and collinear map joints.
+                        const bladeClear = [clear[0] + 0.1, clear[1] + 0.1];
+                        for (let bottom = lo + 0.12; bottom + 0.07 < hi; bottom += 0.22)
+                            ribbon(run, bladeClear, (s) => roof(s) - 0.04, cover, bottom, bottom + 0.07, 0, wall, "blade");
+                    }
+                    for (const [lo, hi] of crown.shadowStrips)
+                        ribbon(run, clear, roof, cover, lo, hi, 0, wall, "shadow");
+                }
+                // Roof edges: only where this volume stands above its neighbour. The lit outline runs
+                // along the four faces; the diagonal edges of the split, the notches, and the slot
+                // take a dark coping. Each run's fascia is a few millimetres wider and deeper than the
+                // last, so where two overlap at a corner no faces share a plane.
+                if (cover && Math.max(cover(0) - roof(0), cover(run.length) - roof(run.length)) > -0.5)
+                    return;
+                const lit = volume.glazed && outer;
+                const step = 0.004 * index, width = (lit ? 0.42 : 0.3) + step;
+                // A sloped roof's fascia carries on past a convex corner, downhill only so none rises
+                // above the peaks. Otherwise it stops short: across a straight joint or into a concave
+                // corner its neighbour's top would share its plane where the two overlapped, and at a
+                // convex corner its end would lie in the plane of the next wall, which a taller
+                // neighbour may carry on up.
+                const adjust = (turn, at, past) => {
+                    if (turn < -straight)
+                        return volume.glazed && volume.roof(run.at(past)) < volume.roof(run.at(at)) ? width : -0.005;
+                    return -(width * Math.tan(Math.abs(turn) / 2) + 0.002);
+                };
+                const extend = [adjust(first ? startTurn : 0, 0, -width), adjust(last ? endTurn : 0, run.length, run.length + width)];
+                fascia(lit ? lights : coping, run, volume.roof, width, (lit ? 0.7 : 0.5) + step, extend);
+            });
+        });
+    });
+    // The sloped glazing's grid, raised a little above the glass along the building's axes and
+    // seated in it, between the glass's top and its underside. The two directions stand and
+    // sit at different depths, so their crossings never share a plane.
+    // Bars keep their full width at least 0.3 m inside the roof's edge.
+    const spacing = 2 * crainFloors.module, inset = 0.9, barHalf = 0.08, barReach = barHalf + 0.3;
+    const { origin, axis } = form.grid;
+    const across = [-axis[1], axis[0]];
+    for (const volume of volumes.filter((v) => v.glazed)) {
+        for (const [direction, normal, lift, seat] of [[axis, across, 0.06, 0.02], [across, axis, 0.09, 0.03]]) {
+            const offsets = volume.corners.map((p) => (p[0] - origin[0]) * normal[0] + (p[1] - origin[1]) * normal[1]);
+            for (let k = Math.ceil(Math.min(...offsets) / spacing + 1e-9); k * spacing < Math.max(...offsets) - 1e-9; k += 1) {
+                const start = [origin[0] + normal[0] * k * spacing, origin[1] + normal[1] * k * spacing];
+                // Clip both long sides of the bar's footprint, not just its centre line, so a bar
+                // running nearly parallel to an edge cannot lean out over it.
+                const side = (offset) => [start[0] + normal[0] * offset, start[1] + normal[1] * offset];
+                const [left, right] = [clipLine(volume.corners, side(-barReach), direction), clipLine(volume.corners, side(barReach), direction)];
+                // The geographic crown follows the observed grid to the edge; the
+                // drawing-fit copies retain their original half-module end snapping.
+                // Geographic ends rely on the building-kit coplanar-overlap check to
+                // catch any end face meeting a crossing bar after grid/inset changes.
+                for (const [a0, a1] of left)
+                    for (const [b0, b1] of right) {
+                        const t0 = form.grid.edgeInset === undefined ? (Math.ceil((Math.max(a0, b0) + inset) / spacing - 0.5) + 0.5) * spacing : Math.max(a0, b0) + form.grid.edgeInset;
+                        const t1 = form.grid.edgeInset === undefined ? (Math.floor((Math.min(a1, b1) - inset) / spacing - 0.5) + 0.5) * spacing : Math.min(a1, b1) - form.grid.edgeInset;
+                        if (t1 - t0 < spacing - 1e-9)
+                            continue;
+                        const p0 = [start[0] + direction[0] * t0, start[1] + direction[1] * t0];
+                        const p1 = [start[0] + direction[0] * t1, start[1] + direction[1] * t1];
+                        roofBox(grid, p0, p1, volume.roof, barHalf, lift, seat);
+                    }
+            }
+        }
+    }
+    const height = Math.max(...volumes.flatMap((volume) => volume.corners.map((p) => y(volume.roof(p)))));
+    return kit.finish({ height, outlines: [shell], opacity: 0.2 });
+}

package/lib/models/facade-grid.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from "../vendor/three-r186.js";
+import type { BatchData, Builder, Plan, Run, Vec2 } from "./building-kit.js";
+export declare const orient: (corners: Vec2[]) => Vec2[];
+export declare const planOf: (corners: Vec2[]) => Plan;
+export declare const turnAt: (a: Run, b: Run) => number;
+export interface Chain {
+    runs: number[];
+    starts: number[];
+    length: number;
+}
+export declare function chainsOf(plan: Plan, straight?: number): Chain[];
+export declare function mitredBox(kit: Builder, target: BatchData, run: Run, s0: number, s1: number, before: number | undefined, after: number | undefined, width: number, lo: number, hi: number, y?: (real: number) => number): void;
+export declare function gridBox(kit: Builder, target: BatchData, run: Run, columns: number[], rows: number[], back: number, front: number, paint: (column: number, row: number) => THREE.Color, sides: THREE.Color, y?: (real: number) => number): void;
+export declare function paintedSlab(kit: Builder, target: BatchData, polygon: [number, number][], height: number, up: boolean, paint: THREE.Color): void;
+export declare const turnsAt: (plan: Plan, index: number) => readonly [number, number];
+export declare function jointTrim(plan: Plan, chain: Chain, froms: number[], k: number, other: number, clearance?: number): number;
+export declare function chainPier(kit: Builder, target: BatchData, plan: Plan, chain: Chain, froms: number[], a: number, b: number, depth: number, top: number | number[], y?: (real: number) => number): void;
+export declare function chainSkin(kit: Builder, target: BatchData, plan: Plan, chain: Chain, k0: number, k1: number, s0: number, s1: number, columns: number[], rows: number[], back: number, front: number, paint: (bay: number, row: number) => THREE.Color, sides: THREE.Color, y?: (real: number) => number): void;

package/lib/models/facade-grid.js

@@ -0,0 +1,176 @@
+import { line } from "./building-kit.js";
+// An outline's corners in the winding that gives every run of its plan an outward normal.
+export const orient = (corners) => {
+    const area = corners.reduce((sum, [x, z], i) => { const [x2, z2] = corners[(i + 1) % corners.length]; return sum + x * z2 - x2 * z; }, 0);
+    return area < 0 ? corners : [...corners].reverse();
+};
+export const planOf = (corners) => corners.map((corner, i) => line(corner, corners[(i + 1) % corners.length]));
+// The turn from run a into run b at their shared corner; negative where the outline turns
+// out (a convex corner) and positive where it turns in.
+export const turnAt = (a, b) => { const n1 = a.normal(a.length), n2 = b.normal(0); return Math.atan2(n1[0] * n2[1] - n1[1] * n2[0], n1[0] * n2[0] + n1[1] * n2[1]); };
+export function chainsOf(plan, straight = 5 * Math.PI / 180) {
+    const breaks = plan.map((run, i) => Math.abs(turnAt(plan[(i + plan.length - 1) % plan.length], run)) >= straight);
+    const first = Math.max(0, breaks.indexOf(true));
+    const chains = [];
+    for (let k = 0; k < plan.length; k += 1) {
+        const i = (first + k) % plan.length, chain = chains.at(-1);
+        if (breaks[i] || !chain)
+            chains.push({ runs: [i], starts: [0], length: plan[i].length });
+        else {
+            chain.runs.push(i);
+            chain.starts.push(chain.length);
+            chain.length += plan[i].length;
+        }
+    }
+    return chains;
+}
+// A closed box standing `width` proud of a run from s0 to s1 and lo to hi: a cap, a band
+// course, a corner pier. An end given the turn at its corner is mitred on that corner's
+// bisector, so the neighbouring run's box meets it in one plane, facing the other way, and
+// the two never overlap; an end without one is square. At a convex corner (a negative turn)
+// the outer edge runs past the wall's end; at a concave one it stops short of it.
+export function mitredBox(kit, target, run, s0, s1, before, after, width, lo, hi, y = (real) => real) {
+    const outer0 = s0 + (before === undefined ? 0 : Math.tan(before / 2) * width), outer1 = s1 - (after === undefined ? 0 : Math.tan(after / 2) * width);
+    const n = run.normal(0);
+    const at = (s, depth, v) => { const q = run.at(s, depth); return [q[0], y(v), q[1]]; };
+    const inner = [at(s0, 0, lo), at(s1, 0, lo), at(s1, 0, hi), at(s0, 0, hi)];
+    const outer = [at(outer0, width, lo), at(outer1, width, lo), at(outer1, width, hi), at(outer0, width, hi)];
+    const normal = (a, b, c) => {
+        const u = [b[0] - a[0], b[1] - a[1], b[2] - a[2]], v = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+        const g = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]], l = Math.hypot(...g);
+        return [g[0] / l, g[1] / l, g[2] / l];
+    };
+    kit.quad(target, [outer[0], outer[1], outer[2], outer[3]], [[n[0], 0, n[1]]]);
+    kit.quad(target, [inner[1], inner[0], inner[3], inner[2]], [[-n[0], 0, -n[1]]]);
+    kit.quad(target, [inner[3], outer[3], outer[2], inner[2]], [[0, 1, 0]]);
+    kit.quad(target, [inner[0], inner[1], outer[1], outer[0]], [[0, -1, 0]]);
+    kit.quad(target, [inner[0], outer[0], outer[3], inner[3]], [normal(inner[0], outer[0], outer[3])]);
+    kit.quad(target, [outer[1], inner[1], inner[2], outer[2]], [normal(outer[1], inner[1], inner[2])]);
+}
+// A closed box on a run, standing `back` to `front` off the wall between the first and last
+// of `columns` along it and the first and last of `rows` up it, whose front is a grid of
+// coloured cells: panes and mullions, window ribbons, louver blades. Its top and bottom fan
+// out from a back corner through every column cut, and its ends through every row cut, so
+// each cell's edge meets its partner and the box closes edge for edge, without the
+// T-junctions a single top face would leave against a cut front. Heights are real heights;
+// `y` maps them to the model's.
+export function gridBox(kit, target, run, columns, rows, back, front, paint, sides, y = (real) => real) {
+    const n = run.normal(0), tangent = [n[1], -n[0]];
+    const at = (s, depth, height) => { const p = run.at(s, depth); return [p[0], y(height), p[1]]; };
+    const [s0, s1] = [columns[0], columns.at(-1)], [y0, y1] = [rows[0], rows.at(-1)];
+    for (let c = 0; c + 1 < columns.length; c += 1) {
+        for (let r = 0; r + 1 < rows.length; r += 1) {
+            const [a, b, lo, hi] = [columns[c], columns[c + 1], rows[r], rows[r + 1]];
+            kit.quad(target, [at(a, front, lo), at(b, front, lo), at(b, front, hi), at(a, front, hi)], [[n[0], 0, n[1]]], paint(c, r));
+        }
+    }
+    kit.quad(target, [at(s1, back, y0), at(s0, back, y0), at(s0, back, y1), at(s1, back, y1)], [[-n[0], 0, -n[1]]], sides);
+    const fan = (hinge, rim, normal) => {
+        for (let i = 0; i + 1 < rim.length; i += 1)
+            kit.triangle(target, [hinge, rim[i], rim[i + 1]], [normal, normal, normal], sides);
+    };
+    fan(at(s0, back, y1), [...columns.map((s) => at(s, front, y1)), at(s1, back, y1)], [0, 1, 0]);
+    fan(at(s0, back, y0), [...columns.map((s) => at(s, front, y0)), at(s1, back, y0)], [0, -1, 0]);
+    fan(at(s0, back, y0), [...rows.map((v) => at(s0, front, v)), at(s0, back, y1)], [-tangent[0], 0, -tangent[1]]);
+    fan(at(s1, back, y0), [...rows.map((v) => at(s1, front, v)), at(s1, back, y1)], [tangent[0], 0, tangent[1]]);
+}
+// A slab in a vertex-coloured batch, painted, since kit.slab lays its vertices white.
+export function paintedSlab(kit, target, polygon, height, up, paint) {
+    const start = target.colors.length;
+    kit.slab(target, polygon, height, up);
+    for (let i = start; i < target.colors.length; i += 3)
+        target.colors.splice(i, 3, paint.r, paint.g, paint.b);
+}
+// The turns at a run's two corners, into it and out of it.
+export const turnsAt = (plan, index) => [turnAt(plan[(index + plan.length - 1) % plan.length], plan[index]), turnAt(plan[index], plan[(index + 1) % plan.length])];
+// Piers and mullions cross the joints of a chain in pieces, one per run, mitred on each
+// joint's bisector as mitred courses are, each standing from its own run's `froms` to its
+// own run's top. Where the cover changes at a joint, the less covered run's last 2 cm stand
+// from the higher cover, so the piece ends clear of the neighbour's wall. A run's cells stop
+// a little short of every joint, of a more covered neighbour, and of the wedge a concave
+// joint would push into the next run's cells: `jointTrim` gives how far, toward `other`.
+// `clearance` is how far cells stop short of a more covered neighbour.
+export function jointTrim(plan, chain, froms, k, other, clearance = 0.01) {
+    if (other < 0 || other >= chain.runs.length)
+        return 0;
+    const [a, b] = other > k ? [chain.runs[k], chain.runs[other]] : [chain.runs[other], chain.runs[k]];
+    const turn = turnAt(plan[a], plan[b]);
+    return 0.005 + (turn > 0 ? 0.08 * Math.tan(turn / 2) : 0) + (froms[k] < froms[other] ? clearance : 0);
+}
+export function chainPier(kit, target, plan, chain, froms, a, b, depth, top, y = (real) => real) {
+    const last = chain.runs.length - 1;
+    chain.runs.forEach((index, k) => {
+        const run = plan[index], start = chain.starts[k], end = start + run.length, ceiling = typeof top === "number" ? top : top[k];
+        const lo = Math.max(a, start), hi = Math.min(b, end);
+        if (hi - lo < 0.005)
+            return;
+        const [before, after] = turnsAt(plan, index);
+        const mitreLo = lo === start && (a < start || (k === 0 && a === 0)) ? before : undefined;
+        const mitreHi = hi === end && (b > end || (k === last && b === chain.length)) ? after : undefined;
+        const pieces = [[lo, hi, froms[k], mitreLo, mitreHi]];
+        if (mitreHi !== undefined && k < last && froms[k] < froms[k + 1] && hi - 0.02 > lo)
+            pieces.splice(0, 1, [lo, hi - 0.02, froms[k], mitreLo, undefined], [hi - 0.02, hi, froms[k + 1], undefined, mitreHi]);
+        const first = pieces[0];
+        if (mitreLo !== undefined && k > 0 && froms[k] < froms[k - 1] && first[1] > lo + 0.02)
+            pieces.splice(0, 1, [lo, lo + 0.02, froms[k - 1], mitreLo, undefined], [lo + 0.02, first[1], first[2], undefined, first[4]]);
+        for (const [p0, p1, from, m0, m1] of pieces) {
+            if (from < ceiling)
+                mitredBox(kit, target, run, p0 - start, p1 - start, m0, m1, depth, Math.max(from, 0.3), ceiling, y);
+        }
+    });
+}
+// A closed box along runs k0 to k1 of a chain, from s0 to s1 along it, standing `back` to
+// `front` off the walls, whose front is a grid of coloured cells cut at `columns` along the
+// chain and at `rows` up it: a curtain wall's glass and spandrels round a traced curve. Where
+// two of its runs meet, its faces meet on the joint's mitre, so a curve carries one box with
+// ends only at s0 and s1. Its tops and bottoms fan out from a back corner through each run's
+// column cuts, and its ends through every row cut, so it closes edge for edge. A cell is
+// painted by its bay, the columns at or before its start, so a cell a joint splits keeps
+// one colour.
+// `paint` runs immediately before its front quad appends six vertices to target.
+// Blue Cross records that vertex offset to address individual window lights.
+export function chainSkin(kit, target, plan, chain, k0, k1, s0, s1, columns, rows, back, front, paint, sides, y = (real) => real) {
+    const lift = (q, v) => [q[0], y(v), q[1]];
+    const mitre = (k, depth) => {
+        const a = plan[chain.runs[k]], b = plan[chain.runs[k + 1]], v = a.at(a.length), n1 = a.normal(a.length), n2 = b.normal(0);
+        const scale = depth / (1 + n1[0] * n2[0] + n1[1] * n2[1]);
+        return [v[0] + (n1[0] + n2[0]) * scale, v[1] + (n1[1] + n2[1]) * scale];
+    };
+    const [y0, y1] = [rows[0], rows.at(-1)];
+    const up = [0, 1, 0], down = [0, -1, 0];
+    const fan = (hinge, rim, normal, paintWith = sides) => {
+        for (let i = 0; i + 1 < rim.length; i += 1)
+            kit.triangle(target, [hinge, rim[i], rim[i + 1]], [normal, normal, normal], paintWith);
+    };
+    for (let k = k0; k <= k1; k += 1) {
+        const run = plan[chain.runs[k]], start = chain.starts[k], n = run.normal(0), out = [n[0], 0, n[1]];
+        const from = k === k0 ? s0 : start, to = k === k1 ? s1 : start + run.length;
+        const cuts = columns.filter((s) => s > from + 1e-6 && s < to - 1e-6);
+        const arcs = [from, ...cuts, to];
+        const at = (s, depth, index) => {
+            if (index === 0 && k > k0)
+                return mitre(k - 1, depth);
+            if (index === arcs.length - 1 && k < k1)
+                return mitre(k, depth);
+            return run.at(s - start, depth);
+        };
+        const fronts = arcs.map((s, i) => at(s, front, i));
+        const [backStart, backEnd] = [at(from, back, 0), at(to, back, arcs.length - 1)];
+        for (let i = 0; i + 1 < fronts.length; i += 1) {
+            const bay = columns.filter((s) => s <= arcs[i] + 1e-6).length;
+            for (let r = 0; r + 1 < rows.length; r += 1) {
+                kit.quad(target, [lift(fronts[i], rows[r]), lift(fronts[i + 1], rows[r]), lift(fronts[i + 1], rows[r + 1]), lift(fronts[i], rows[r + 1])], [out], paint(bay, r));
+            }
+        }
+        kit.quad(target, [lift(backEnd, y0), lift(backStart, y0), lift(backStart, y1), lift(backEnd, y1)], [[-n[0], 0, -n[1]]], sides);
+        fan(lift(backStart, y1), [...fronts.map((q) => lift(q, y1)), lift(backEnd, y1)], up);
+        fan(lift(backStart, y0), [...fronts.map((q) => lift(q, y0)), lift(backEnd, y0)], down);
+    }
+    // The ends, square to their runs.
+    const ends = [[k0, s0, -1], [k1, s1, 1]];
+    for (const [k, s, sign] of ends) {
+        // Outward along the run at s1, back along it at s0.
+        const run = plan[chain.runs[k]], start = chain.starts[k], n = run.normal(0), t = [n[1] * sign, 0, -n[0] * sign];
+        fan(lift(run.at(s - start, back), y0), [...rows.map((v) => lift(run.at(s - start, front), v)), lift(run.at(s - start, back), y1)], t);
+    }
+}

package/lib/models/gage-geographic.d.ts

@@ -0,0 +1,19 @@
+import type { BuildingModel, Plan } from "./building-kit.js";
+import type { GeoBuilding } from "./skyline-geography-data.js";
+export declare const gageLevels: Readonly<{
+    shopfront: 4;
+    second: 5.2;
+    eighth: number;
+    pitch: number;
+    top: 46.94;
+    cartouches: 47.74;
+}>;
+export declare const gagePalette: Readonly<{
+    glass: number[];
+    lit: 7237230;
+    dim: 3815994;
+    terracotta: 6184542;
+    band: 4737096;
+    brick: 4210752;
+}>;
+export declare function createGageGeographicBuilding(record: GeoBuilding, projectPlan: (coordinates: [number, number][]) => Plan, offset: [number, number]): BuildingModel;