@a2f0/skyline 0.0.0-stage → 0.1.1

package/site/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/site/models/gage-geographic.js

@@ -0,0 +1,154 @@
+import * as THREE from "../vendor/three-r186.js";
+import { createBuilder, polygonOf } from "./building-kit.js";
+import { chainSkin, chainsOf, orient, paintedSlab, planOf, turnsAt } from "./facade-grid.js";
+// The Gage Building, 18 South Michigan Avenue (Holabird & Roche, with a front by Louis
+// Sullivan, 1899; four storeys added in 1902): the geographic layout's model, on the mapped
+// outline 124865450. The original layout has no model of it; the drawing shows its Michigan
+// front and, above its lower neighbours at 24 and 30 South Michigan, its south wall, between
+// the University Club and Willoughby Tower.
+//
+// A terracotta front of three bays between tall piers rises twelve storeys, a wide window of
+// several lights to each bay and floor, to a parapet with cartouches over the inner piers.
+// The south wall is common brick, windowed near the front and on two floors. The parapet is
+// the City's 154 ft, the published height nearest the drawing's reading. The drawn parapet
+// reads 54.2 m, so heights read on the drawing are scaled to meet it; see
+// docs/gage-reference.md. Units are meters; +x is east, +z is south.
+const drawn = (height) => height * 46.94 / 54.2;
+export const gageLevels = Object.freeze({
+    shopfront: 4, // the ground floor's shop windows, under a sign band
+    second: 5.2, // the second floor
+    eighth: drawn(33.47), // the eighth floor, the lowest the drawing shows
+    pitch: drawn(3.715), // each floor from the eighth up, as drawn
+    top: 46.94, // the parapet, the City's 154 ft
+    cartouches: 47.74, // the cartouches over the inner piers
+});
+const h = gageLevels;
+// Each floor's level: the ground floor, six floors of 3.97 m to the eighth, which the hill
+// hides, and the drawn floors above it.
+const floor = (n) => (n < 2 ? 0 : n <= 8 ? h.second + (n - 2) * (h.eighth - h.second) / 6 : h.eighth + (n - 8) * h.pitch);
+// The skins' colours: the window tones, and the terracotta and the brick, which no window
+// shares.
+export const gagePalette = Object.freeze({ glass: [0x262626, 0x2a2a2a, 0x2e2e2e, 0x323232], lit: 0x6e6e6e, dim: 0x3a3a3a, terracotta: 0x5e5e5e, band: 0x484848, brick: 0x404040 });
+const palette = gagePalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim);
+const terracotta = color(palette.terracotta), band = color(palette.band), brick = color(palette.brick);
+const core = color(0x262626), roofing = color(0x3a3a3a);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 43, 0x9e3779b1) ^ Math.imul(bay + 67, 0x85ebca77) ^ Math.imul(wall + 53, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 4)
+        return litGlass;
+    if (value < 8)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+const rows = [
+    { lo: 0.25, hi: 0.9, kind: "wall", floor: 1 },
+    { lo: 0.9, hi: h.shopfront, kind: "glass", floor: 1 },
+    { lo: h.shopfront, hi: h.second, kind: "band", floor: 1 },
+];
+for (let n = 2; n <= 12; n += 1) {
+    rows.push({ lo: rows.at(-1).hi, hi: floor(n) + drawn(0.86), kind: "wall", floor: n });
+    rows.push({ lo: floor(n) + drawn(0.86), hi: floor(n) + drawn(3.29), kind: "glass", floor: n });
+}
+rows.push({ lo: rows.at(-1).hi, hi: h.top, kind: "wall", floor: 13 });
+export function createGageGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Gage Building · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Gage Building · terracotta and windows", kit.material(0xffffff, { vertexColors: true }));
+    const cartouches = kit.batch("Gage Building · cartouches", kit.material(0x6a6a6a));
+    const lot = orient(polygonOf(projectPlan(record.footprint.coordinates)));
+    // The lot's south-east corner, with its south wall running west along 24 South Michigan
+    // and its Michigan front north to the Chicago Athletic Association.
+    const corner = lot.reduce((best, p) => (p[0] + p[1] > best[0] + best[1] ? p : best));
+    const northEast = lot.reduce((best, p) => (p[0] - p[1] > best[0] - best[1] ? p : best));
+    const southWest = lot.reduce((best, p) => (p[1] - p[0] > best[1] - best[0] ? p : best));
+    const unit = (p) => { const d = Math.hypot(p[0] - corner[0], p[1] - corner[1]); return [(p[0] - corner[0]) / d, (p[1] - corner[1]) / d]; };
+    const west = unit(southWest), north = unit(northEast);
+    const at = (a, b) => [corner[0] + west[0] * a + north[0] * b, corner[1] + west[1] * a + north[1] * b];
+    // The inverse of `at`: a point's distances along the south wall and the Michigan front,
+    // which meet a little off square.
+    const skew = west[0] * north[1] - west[1] * north[0];
+    const inLot = (p) => {
+        const [x, z] = [p[0] - corner[0], p[1] - corner[1]];
+        return [(x * north[1] - z * north[0]) / skew, (west[0] * z - west[1] * x) / skew];
+    };
+    const rect = (a0, a1, b0, b1) => orient([at(a0, b0), at(a1, b0), at(a1, b1), at(a0, b1)]);
+    planOf(lot).forEach((run) => {
+        const a = run.at(0), b = run.at(run.length), n = run.normal(0);
+        kit.quad(shell, [[a[0], 0, a[1]], [b[0], 0, b[1]], [b[0], h.top, b[1]], [a[0], h.top, a[1]]], [[n[0], 0, n[1]]], core);
+    });
+    paintedSlab(kit, shell, lot, 0, false, roofing);
+    paintedSlab(kit, shell, lot, h.top, true, roofing);
+    // The cartouches that end the inner piers, rising clear of the parapet: two blocks on the
+    // roof, 5 cm inside the front's plane.
+    for (const b of [5.6, 11.3])
+        kit.prism(cartouches, planOf(rect(0.05, 0.85, b + 0.05, b + 1.15)), [h.top, h.cartouches]);
+    const skin = (seed, keep, openings) => {
+        const plan = planOf(lot), heights = [rows[0].lo, ...rows.map((row) => row.hi)];
+        chainsOf(plan).forEach((chain, index) => {
+            if (!chain.runs.every((run) => keep(plan[run])))
+                return;
+            const first = chain.runs[0], last = chain.runs.at(-1);
+            const s0 = turnsAt(plan, first)[0] > 0 ? 0.09 : 0.02, s1 = chain.length - (turnsAt(plan, last)[1] > 0 ? 0.09 : 0.02);
+            const [columns, column] = openings(chain.length, plan[first].at(0), plan[last].at(plan[last].length));
+            chainSkin(kit, wall, plan, chain, 0, chain.runs.length - 1, s0, s1, columns, heights, 0.02, 0.07, (bay, r) => {
+                const row = rows[r], { face, floors } = column(bay);
+                if (row.kind === "band")
+                    return face === brick ? brick : band;
+                return row.kind === "glass" && floors(row.floor) ? paneColor(row.floor, bay, seed * 8 + index) : face;
+            }, face(seed));
+        });
+    };
+    const face = (seed) => (seed === 0 ? terracotta : brick);
+    // A position along a wall from its start, given in lot coordinates across it.
+    const along = (length, start, end, axis) => {
+        const [p, q] = [inLot(start)[axis], inLot(end)[axis]];
+        return [(target) => length * (target - p) / (q - p), (s) => p + (s / length) * (q - p)];
+    };
+    // Windows spanning `spans`, in lot coordinates along `axis`, glazed on the floors `floors`
+    // gives; a window's lights are split by its mullions at `mullions`.
+    const windows = (length, start, end, axis, spans, floors, face, mullions = []) => {
+        const [to, from] = along(length, start, end, axis);
+        const inside = spans.map(([a, b]) => [to(a), to(b)].sort((p, q) => p - q)).filter(([a, b]) => a > 0.1 && b < length - 0.1);
+        const cuts = [...inside.flat(), ...mullions.map(to).flatMap((s) => [s - 0.06, s + 0.06])].filter((s) => s > 0.1 && s < length - 0.1);
+        const columns = [0, ...[...new Set(cuts)].sort((p, q) => p - q), length];
+        // Bays count from one, each between two columns; a bay holds a window when its middle
+        // lies inside one and off its mullions.
+        return [columns, (bay) => {
+                const middle = (columns[bay - 1] + columns[bay]) / 2;
+                const glazed = inside.some(([a, b]) => middle > a && middle < b) && !mullions.map(to).some((s) => Math.abs(middle - s) < 0.06);
+                return { face, floors: glazed ? floors(from(middle)) : () => false };
+            }];
+    };
+    const facing = (x, z) => (run) => run.normal(0)[0] * x + run.normal(0)[1] * z > 0.9;
+    const [isMichigan, isSouth] = [facing(1, 0), facing(0, 1)];
+    // The Michigan front, measured on the drawing from the south corner: corner piers 2 m wide,
+    // inner piers 1.15 and 1.2 m; the south and north bays' windows 3.6 m wide in four lights,
+    // the middle one's 4.55 m in five.
+    const bays = [[2, 5.6], [6.75, 11.3], [12.5, 16.1]];
+    const lights = [2.9, 3.8, 4.7, 7.66, 8.57, 9.48, 10.39, 13.4, 14.3, 15.2];
+    const michigan = (length, start, end) => windows(length, start, end, 1, bays, () => () => true, terracotta, lights);
+    // The south wall, measured on the drawing west from the front: a window 6 to 9.5 m in on
+    // the top four floors, and three more between 15.3 and 28.4 m on the ninth and twelfth, as
+    // drawn. The University Club hides the rest.
+    const southWall = (length, start, end) => windows(length, start, end, 0, [[6, 9.5], [15.3, 18.8], [20.3, 23.8], [24.8, 28.4]], (a) => (a < 10 ? (n) => n >= 9 : (n) => n === 9 || n === 12), brick);
+    // The alley: windows 1.6 m wide spread evenly about 3.2 m apart on every floor above the
+    // ground floor. The north wall, shared with the Chicago Athletic Association, stays plain.
+    const alley = (length, start, end) => {
+        const [, from] = along(length, start, end, 1), count = Math.max(1, Math.round(length / 3.2));
+        const spans = Array.from({ length: count }, (_, i) => { const c = from(length * (i + 0.5) / count); return [c - 0.8, c + 0.8]; });
+        return windows(length, start, end, 1, spans, () => (n) => n >= 2, brick);
+    };
+    skin(0, isMichigan, michigan);
+    skin(1, isSouth, southWall);
+    skin(2, facing(-1, 0), alley);
+    skin(3, facing(0, -1), (length) => [[0, length], () => ({ face: brick, floors: () => false })]);
+    const model = kit.finish({ height: h.cartouches, outlines: [shell, cartouches], opacity: 0.16 });
+    model.building.position.set(offset[0], 0, offset[1]);
+    model.building.userData["geography"] = record;
+    model.building.userData["geographicDetail"] = { levels: h, source: "docs/gage-reference.md" };
+    return model;
+}

package/site/models/heritage-at-millennium-park.js

@@ -0,0 +1,284 @@
+import * as THREE from "../vendor/three-r186.js";
+import { along, arc, bulge, cornerNormal, createBuilder, deg, evenly, inside, line, point, station } from "./building-kit.js";
+// Plan and heights are fitted numerically to the source SVG through the skyline
+// camera: corners, mullions, and crown fins follow the drawing. The camera-facing flat
+// face and bow radius are about 1.3x the OpenStreetMap trace; the hidden north and west
+// faces are simplified closures (a straight north face and one shallow west bulge), not
+// that outline. Units are meters; +x is east (right in the skyline view), +z is south.
+// The kit's 2.4° arc facets give two per bow bay, so the silhouette stays round.
+// The drawing's floor pitch; its six-floor bands and the lower tier's three-floor
+// bands share one grid. Floor 0 is the crown base, floor 30 the lower-tier ledge.
+const floorHeight = 3.794;
+const crownBase = 175.4;
+const level = (floor) => crownBase - floor * floorHeight;
+const parapet = 191.3, capSoffit = 189.1, capProud = 1.2, bandProud = 0.34;
+const lowerParapet = 74.3, lowerSoffit = lowerParapet - 2.6, lowerLedge = level(30), lowerCapProud = 0.66;
+const screenTop = 204.6, penthouseTop = 202.3;
+// Tower plan, left to right in the skyline view: the south stub, a flat south face,
+// the convex east bow, and a flat north strip along the bow's end tangent.
+const joint = [13, 23];
+const stubLength = 12, stubDepth = 4.4, flatLength = 18.7, stripLength = 13.95;
+const stubA = [joint[0] - flatLength - stubLength, joint[1] + stubDepth];
+const stubB = [joint[0] - flatLength, joint[1] + stubDepth];
+const stubC = [joint[0] - flatLength, joint[1]];
+const bowStart = 63 * deg, bowEnd = bowStart + 38.4 * deg, bowRadius = 57;
+const bow = arc([joint[0] - bowRadius * Math.sin(bowStart), joint[1] - bowRadius * Math.cos(bowStart)], bowRadius, bowStart, bowEnd);
+const bowEndPoint = bow.at(bow.length);
+const strip = line(bowEndPoint, [bowEndPoint[0] + stripLength * Math.cos(bowEnd), bowEndPoint[1] - stripLength * Math.sin(bowEnd)]);
+const northEast = strip.at(strip.length);
+const northWest = [-13, northEast[1]], westEnd = [stubA[0], 21];
+const flatFace = line(stubC, joint), north = line(northEast, northWest), westBulge = bulge(northWest, westEnd, 2.5);
+const tower = [line(stubA, stubB), line(stubB, stubC), flatFace, bow, strip, north, westBulge, line(westEnd, stubA)];
+// Lower tier: a shallow concave Garland Court face whose north end stands just
+// proud of the bow. Its unlit south part is trimmed along the skyline view's line
+// of sight, turned 3° away, so nothing appears left of the drawn silhouette.
+const lowerNorth = bow.at(12.1, 0.3);
+const lowerHeading = 77.1 * deg, lowerRadius = 100, lowerLength = 49.3, lowerSouthLength = 3.56;
+const lowerCenter = [lowerNorth[0] + lowerRadius * Math.sin(lowerHeading), lowerNorth[1] + lowerRadius * Math.cos(lowerHeading)];
+const lowerFace = arc(lowerCenter, lowerRadius, lowerHeading + lowerLength / lowerRadius, lowerHeading, true);
+// Near its north end the face runs inside the tower's thick bands. Lower bands on those
+// floors stop short, and a shallower piece on a run 0.04 m farther out carries each on to
+// the face's end, clear of the tower band's ledges.
+const junctionTrim = 0.8, junctionInset = 0.04;
+const junction = arc(lowerCenter, lowerRadius - junctionInset, lowerHeading + junctionTrim / lowerRadius, lowerHeading, true);
+const lowerSE = lowerFace.at(0), lowerSW = [lowerSE[0] - lowerSouthLength, lowerSE[1]];
+const sightline = 38.5 * deg, lowerWestX = stubC[0] - 1.3;
+const chamferLength = (lowerSW[0] - lowerWestX) / Math.sin(sightline);
+const lowerChamfer = [lowerWestX, lowerSW[1] - chamferLength * Math.cos(sightline)];
+const lowerWestNorth = [lowerWestX, lowerNorth[1]];
+const lowerTier = [line(lowerSW, lowerSE), lowerFace, line(lowerNorth, lowerWestNorth), line(lowerWestNorth, lowerChamfer), line(lowerChamfer, lowerSW)];
+// Bay stations along each run, in meters from its start. Hidden runs place mullions
+// on interior stations; the camera-facing runs use the fourteen drawn mullions below.
+const flatBay = (flatLength - 1) / 3, lowerPitch = 4.84, lowerMargin = 3.85;
+const stripStations = [6.35, 12.7];
+const towerStations = [
+    [0, 6, stubLength], [0, stubDepth], [0, 1, 1 + flatBay, 1 + 2 * flatBay, flatLength], evenly(bow.length, 8),
+    [0, ...stripStations, strip.length], evenly(north.length, 6), evenly(westBulge.length, 10), evenly(tower[7].length, 2),
+];
+const lowerFinStations = Array.from({ length: 10 }, (_, i) => lowerMargin + i * lowerPitch);
+const lowerStations = [[0, lowerSouthLength], [0, ...lowerFinStations, lowerLength], [0, 1], evenly(lowerTier[3].length, 4), evenly(chamferLength, 7)];
+const jointStation = { at: joint, normal: cornerNormal(flatFace.normal(), bow.normal(0)) };
+// Fourteen drawn mullions: three on the flat face, the joint, eight bow bays, two on
+// the strip. The twelfth, at the bow's end, is the center of the balcony stack.
+const mullions = [
+    ...[1, 1 + flatBay, 1 + 2 * flatBay].map((s) => station(flatFace, s)), jointStation,
+    ...evenly(bow.length, 8).slice(1).map((s) => station(bow, s)), ...stripStations.map((s) => station(strip, s)),
+];
+const balconyStack = mullions[11];
+const crownFins = mullions.slice(1);
+// The crown continues around the hidden north and west faces, so orbits find it finished.
+const hiddenFins = [
+    ...towerStations[5].slice(1, -1).map((s) => station(north, s)),
+    ...towerStations[6].slice(1, -1).map((s) => station(westBulge, s)),
+];
+const lowerFins = lowerFinStations.map((s) => station(lowerFace, s));
+// Screen strip over the north-east corner; the lower part of the same block,
+// with its open cornice frame, steps back to the west.
+const screen = { east: northEast[0] - 0.5, north: northEast[1], width: 7.4, length: 44.08 };
+const penthouse = { west: screen.east - screen.width - 14.74, front: screen.north + screen.length - 1.04, overhang: 1.1 };
+// The crown cap and thick bands start under the first fin, as drawn. The cap stops
+// short of the north-east corner to stay inside the drawn silhouette, and resumes on
+// the hidden north face once the tower itself hides its projection.
+const capStart = 5.5, capEnd = strip.length - 2, northCapStart = 1.6;
+const finWidth = 1.3, finDepth = 0.9, lowerFinWidth = 1.5, lowerFinDepth = 0.7;
+const midpoint = (a, b) => [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+// Features the skyline test projects against the drawing, derived from the geometry above.
+export const heritageFeatures = {
+    screenFrontTop: [screen.east, screenTop, screen.north + screen.length],
+    screenNorthTop: [screen.east, screenTop, screen.north],
+    screenSouthTop: [screen.east - screen.width, screenTop, screen.north + screen.length],
+    penthouseCorniceTip: [penthouse.west - penthouse.overhang, penthouseTop, penthouse.front + penthouse.overhang],
+    stubFrontRoof: point(stubB, parapet),
+    stubLeftRoof: point(stubA, parapet),
+    reentrantRoof: point(stubC, parapet),
+    // The cap crests on the outer edge of its chamfer over the joint.
+    capApex: point(midpoint(flatFace.at(flatLength, capProud), bow.at(0, capProud)), parapet),
+    capSouthEnd: point(flatFace.at(capStart, capProud), parapet),
+    capNorthEnd: point(strip.at(capEnd, capProud), parapet),
+    crownFootNorth: point(northEast, crownBase),
+    lowerCapSouthCorner: point(lowerFace.at(0, lowerCapProud), lowerParapet),
+    lowerCapNorth: point(lowerFace.at(lowerLength, lowerCapProud), lowerParapet),
+    lowerFinFootNorth: point(along(lowerFins.at(-1), lowerFinDepth, lowerFinWidth / 2), lowerLedge),
+    // The lower tier's leftmost wall corner, and the cap and band overhangs beside it.
+    lowerSouthWest: [
+        point(lowerSW, lowerParapet), point(lowerSW, 0),
+        point(lowerTier[0].at(0, lowerCapProud), lowerParapet), point(lowerTier[0].at(0, bandProud), lowerLedge),
+    ],
+    mullions: mullions.map((m) => point(m.at, 120)),
+    crownFins: crownFins.map((m) => point(along(m, finDepth / 2), crownBase + 6)),
+    lowerFins: lowerFins.map((m) => point(along(m, lowerFinDepth / 2), lowerLedge + 4)),
+    bowFacade: point(bow.at(bow.length / 2, 0.05), 130),
+    // Low on the strip just short of the north-east corner, where the drawing shows Kemper's
+    // left face in front of Heritage.
+    northStripFacade: point(strip.at(strip.length - 0.5, 0.05), 60),
+};
+export function createHeritageAtMillenniumParkBuilding() {
+    const kit = createBuilder("The Heritage at Millennium Park", "building-heritage-at-millennium-park");
+    const { material, batch, panel, band, box, prism } = kit;
+    // Base colors sit off the drawing's tones (a #474747 face, #212121 bands, #787878 precast,
+    // a #919191 screen) so the toon-lit result lands near them.
+    const facade = material(0x363636);
+    const glass = material(0xffffff, { vertexColors: true });
+    const relief = material(0x141414);
+    const precast = material(0x8c8c8c);
+    const mechanical = material(0xa4a4a4);
+    const shell = batch("closed tower and lower-tier shells", facade);
+    const panes = batch("window panes", glass);
+    const dark = batch("mullions, bands, and screen louvers", relief);
+    const stone = batch("crown fins, caps, and penthouse frame", precast);
+    const block = batch("rooftop screen", mechanical);
+    // The crown-base seam puts the drawn north crown foot on a shell vertex.
+    const towerPlan = prism(shell, tower, [0, crownBase, parapet]);
+    // The tower's floor already closes the footprint the two volumes share, and the rest
+    // faces the ground, which no camera above it sees.
+    const lowerPlan = prism(shell, lowerTier, [0, lowerParapet], { omit: ["bottom"] });
+    // Details hidden inside the other volume are skipped rather than buried.
+    const towerVisible = (at, y) => y > lowerParapet || !inside(lowerPlan, at);
+    const lowerVisible = (at) => !inside(towerPlan, at);
+    // The trimmed chamfer and west wall are cut faces, so the lower bands and cap wrap
+    // only the south and Garland Court faces and close with return ends.
+    const lowerChain = [lowerTier[0], lowerTier[1]];
+    // One pane per floor per bay, set just proud of the wall like Crain's windows, so only
+    // mullions and slab edges divide the face, as drawn. Tones vary subtly, with scattered lit and dark units.
+    const towerRows = [[0.6, level(45) - 0.22]];
+    for (let floor = 44; floor >= 0; floor -= 1)
+        towerRows.push([level(floor + 1) + 0.2, level(floor) - 0.22]);
+    const crownMid = (crownBase + capSoffit) / 2;
+    const tones = [0x444444, 0x474747, 0x4a4a4a].map((hex) => new THREE.Color(hex));
+    const lit = new THREE.Color(0x7a7a7a), unlit = new THREE.Color(0x3a3a3a);
+    function glaze(runs, stationsList, rows, visible, seed) {
+        runs.forEach((run, r) => {
+            const stations = stationsList[r];
+            for (let bay = 0; bay < stations.length - 1; bay += 1) {
+                if (stations[bay + 1] - stations[bay] < 1.5)
+                    continue;
+                const s0 = stations[bay] + 0.24, s1 = stations[bay + 1] - 0.24;
+                rows.forEach(([bottom, top], row) => {
+                    if (!visible(run.at((s0 + s1) / 2, 0.3), bottom))
+                        return;
+                    const hash = (row * 131 + bay * 37 + r * 59 + seed) % 97;
+                    panel(panes, run, s0, s1, bottom, top, 0.05, hash < 5 ? lit : hash < 8 ? unlit : tones[hash % 3]);
+                });
+            }
+        });
+    }
+    // The stub has no crown, so its top storey runs up to the parapet.
+    const stubTop = [crownBase + 0.45, parapet - 1.2];
+    glaze(tower.slice(0, 2), towerStations.slice(0, 2), [...towerRows, stubTop], towerVisible, 3);
+    glaze([tower.at(-1)], [towerStations.at(-1)], [...towerRows, stubTop], towerVisible, 5);
+    glaze(tower.slice(2, 7), towerStations.slice(2, 7), [...towerRows, [crownBase + 0.5, crownMid - 0.3], [crownMid + 0.3, capSoffit - 0.2]], towerVisible, 11);
+    const lowerRows = [[0.6, level(45) - 0.22]];
+    for (let floor = 44; floor >= 30; floor -= 1)
+        lowerRows.push([level(floor + 1) + 0.2, level(floor) - 0.22]);
+    lowerRows.push([lowerLedge + 0.4, lowerSoffit - 0.25]);
+    glaze(lowerTier, lowerStations, lowerRows, lowerVisible, 23);
+    // Raised mullions run to the crown; the fins take over above it. Every mullion ending
+    // at the crown base stands inside that floor's band, whose top closes its own.
+    const mullion = (target, { at, normal }, y0, y1, { width = 0.28, depth = 0.22, omit = [] } = {}) => box(target, at, normal, width / 2, 0, depth, y0, y1, { omit });
+    const inCrownBand = ["top"];
+    const towerFoot = (at) => (towerVisible(at, 0) ? 0 : lowerParapet);
+    tower.forEach((run, r) => {
+        if (r >= 2 && r <= 4)
+            return;
+        const top = r < 2 || r === 7 ? parapet : crownBase;
+        for (const s of towerStations[r].slice(1, -1)) {
+            const where = station(run, s);
+            mullion(dark, where, towerFoot(where.at), top, { omit: top === crownBase ? inCrownBand : [] });
+        }
+    });
+    // The last two stations take the north strip's wide dark strips below instead. The
+    // first mullion stands before the thick bands begin, so it keeps its top.
+    for (const where of mullions.slice(0, -2)) {
+        if (where !== balconyStack)
+            mullion(dark, where, towerFoot(where.at), crownBase, { omit: where === mullions[0] ? [] : inCrownBand });
+    }
+    // The balcony stack at the bow's end is a dark panel recessed between raised jambs;
+    // wide dark strips follow on the north strip. The jambs stand 3 cm inside the bands'
+    // depth, clear of their arc facets' sag, so the bands wrap them as they wrap the mullions.
+    const stackHalf = 0.75;
+    panel(dark, bow, bow.length - stackHalf, bow.length, 0, crownBase, 0.08);
+    panel(dark, strip, 0, stackHalf, 0, crownBase, 0.08);
+    for (const jamb of [station(bow, bow.length - stackHalf), station(strip, stackHalf)])
+        mullion(dark, jamb, 0, crownBase, { width: 0.24, depth: 0.31, omit: inCrownBand });
+    for (const where of mullions.slice(-2))
+        mullion(dark, where, 0, crownBase, { width: 0.9, depth: 0.24, omit: inCrownBand });
+    // Six-floor bands on the tower and three-floor bands on the lower tier; thin slab
+    // edges mark the other floors on the faces the skyline view sees. Bands follow whole
+    // runs or straight ones, so the wall's own facets close their backs.
+    const onWall = ["back"];
+    const bandRuns = tower.slice(2, 7), stubRuns = [tower[7], tower[0], tower[1]];
+    for (let floor = 0; floor <= 45; floor += 1) {
+        const y = level(floor);
+        // Thick bands start under the first crown fin, as drawn; a slab edge runs before them.
+        if (floor % 6 === 0) {
+            band(dark, bandRuns, y - 0.65, y, bandProud, { omit: onWall, from: capStart, visible: towerVisible });
+            band(dark, [flatFace], y - 0.18, y + 0.04, 0.12, { omit: onWall, to: capStart, visible: towerVisible });
+        }
+        else
+            band(dark, tower.slice(2, 5), y - 0.18, y + 0.04, 0.12, { omit: onWall, visible: towerVisible });
+        // The stub's edges stop at the flat face's slab edge, which turns the re-entrant corner.
+        if (floor % 3 === 0)
+            band(dark, stubRuns, y - 0.2, y + 0.04, 0.12, { omit: onWall, to: stubDepth - 0.12, visible: towerVisible });
+        if (floor >= 30) {
+            if (floor % 6 === 0) {
+                // The trimmed band's facets differ from the wall's, so it keeps its back, and its
+                // end return closes the start of the shallower piece.
+                band(dark, lowerChain, y - 0.65, y, bandProud, { to: lowerLength - junctionTrim, visible: lowerVisible });
+                band(dark, [junction], y - 0.65, y, bandProud - junctionInset, { omit: ["start"], visible: lowerVisible });
+            }
+            else if (floor % 3 === 0)
+                band(dark, lowerChain, y - 0.65, y, bandProud, { omit: onWall, visible: lowerVisible });
+            else
+                band(dark, [lowerTier[1]], y - 0.18, y + 0.04, 0.12, { omit: onWall, visible: lowerVisible });
+        }
+    }
+    // Crown: radial fins under a projecting cap that follows the plan and wraps the
+    // hidden faces. A flush precast pier turns the north-east corner between the cap ends.
+    // The cap's soffit closes each fin's top, except the last strip fin, which stands past the cap's end.
+    for (const where of [...crownFins, ...hiddenFins]) {
+        box(stone, where.at, where.normal, finWidth / 2, 0, finDepth, crownBase, capSoffit, { omit: where === crownFins.at(-1) ? [] : ["top"] });
+    }
+    band(stone, tower.slice(2, 5), capSoffit, parapet, capProud, { omit: onWall, from: capStart, to: capEnd });
+    band(stone, [north, westBulge], capSoffit, parapet, capProud, { omit: onWall, from: northCapStart });
+    // The pier stands on the crown-base band, whose top closes its soffit.
+    band(stone, [strip, north], crownBase, parapet, 0.08, { omit: [...onWall, "soffit"], from: capEnd, to: northCapStart });
+    // Lower fins stand slightly proud of the lower cap, so they keep their tops.
+    for (const where of lowerFins)
+        box(stone, where.at, where.normal, lowerFinWidth / 2, 0, lowerFinDepth, lowerLedge, lowerSoffit);
+    band(stone, lowerChain, lowerSoffit, lowerParapet, lowerCapProud, { omit: onWall, visible: lowerVisible });
+    // Rooftop block: the tall screen strip, then the lower loggia with four posts and a
+    // dark back wall under a cornice that overhangs to the south and west. The roof closes
+    // the bottoms of everything standing on it. The loggia ends at the screen's west face, so
+    // their north faces meet without overlapping.
+    const south = [0, 1];
+    const onRoof = ["bottom"];
+    const screenFront = screen.north + screen.length;
+    box(block, [screen.east - screen.width / 2, screenFront], south, screen.width / 2, -screen.length, 0, parapet, screenTop, { omit: onRoof });
+    const loggiaEast = screen.east - screen.width, lintel = penthouseTop - 1.68, backWall = penthouse.front - 1.5;
+    box(shell, [(penthouse.west + loggiaEast) / 2, backWall], south, (loggiaEast - penthouse.west) / 2, screen.north - backWall, 0, parapet, lintel, { omit: onRoof });
+    const corniceWest = penthouse.west - penthouse.overhang, corniceFront = penthouse.front + penthouse.overhang;
+    // The back wall stops at the lintel, so the cornice closes its own north face.
+    box(stone, [(corniceWest + loggiaEast) / 2, corniceFront], south, (loggiaEast - corniceWest) / 2, screen.north - corniceFront, 0, lintel, penthouseTop);
+    // Post spans in meters east of the loggia's west end, as drawn. The back wall and the
+    // cornice close each post's back and top.
+    const posts = [[0, 1.3], [4.5, 5.9], [9.4, 11.1], [12.3, 13.5]];
+    for (const [left, right] of posts) {
+        box(stone, [penthouse.west + (left + right) / 2, penthouse.front], south, (right - left) / 2, -1.5, 0, parapet, lintel, { omit: [...onRoof, "back", "top"] });
+    }
+    // Louvers and five rows of panel dashes on the screen's two visible faces.
+    const screenSouthWest = [screen.east - screen.width, screenFront], screenSouthEast = [screen.east, screenFront];
+    const screenRuns = [line(screenSouthWest, screenSouthEast), line(screenSouthEast, [screen.east, screen.north])];
+    const dashDrops = [2.06, 4.01, 5.95, 8.1, 10.3];
+    screenRuns.forEach((run, r) => {
+        const panels = r === 0 ? 2 : 10, width = run.length / panels;
+        for (let i = 1; i < panels; i += 1)
+            mullion(dark, station(run, width * i), parapet + 0.3, screenTop - 0.4, { width: 0.25, depth: 0.12 });
+        for (let i = 0; i < panels; i += 1) {
+            for (const drop of dashDrops)
+                panel(dark, run, width * (i + 0.14), width * (i + 0.86), screenTop - drop - 0.18, screenTop - drop, 0.08);
+        }
+    });
+    // Silhouette lines for the shells and the screen only. The 20° threshold is well
+    // above the 2.4° bow facets, so curved faces read as one surface.
+    return kit.finish({ height: screenTop, outlines: [shell, block] });
+}