@a2f0/skyline 0.0.0-stage → 0.1.1

package/site/models/lake-view-geographic.js

@@ -0,0 +1,134 @@
+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 Lake View Building, 116 South Michigan Avenue (Jenney, Mundie & Jensen; its top five
+// storeys added by them in 1912): the geographic layout's model, on the mapped outline
+// 145498711. The original layout has no model of it; the drawing shows it between Peoples
+// Gas and the MacLean Center.
+//
+// A narrow stone front, three windows to a floor, rises seventeen storeys: arched windows
+// on the sixteenth, small attic windows on the seventeenth, and a cornice band at the top.
+// The top is the Skyscraper Center's 73.2 m. The drawn front's top reads 71.9 m, so heights
+// read on the drawing are scaled to meet it; see docs/lake-view-reference.md. Units are
+// meters; +x is east, +z is south.
+const drawn = (height) => height * 73.2 / 71.9;
+export const lakeViewLevels = Object.freeze({
+    attic: drawn(67.9), // the seventeenth floor, with its small windows
+    cornice: drawn(70.8), // the cornice band
+    top: 73.2, // the published top
+});
+const h = lakeViewLevels;
+// The skins' colours: the window tones, and the stone and its cornice, which no window
+// shares.
+export const lakeViewPalette = Object.freeze({ glass: [0x2c2c2c, 0x303030, 0x343434, 0x383838], lit: 0x6e6e6e, dim: 0x3c3c3c, stone: 0x767676, band: 0x888888 });
+const palette = lakeViewPalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim);
+const stone = color(palette.stone), band = color(palette.band), core = color(0x262626), roofing = color(0x3c3c3c);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 59, 0x9e3779b1) ^ Math.imul(bay + 83, 0x85ebca77) ^ Math.imul(wall + 71, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 4)
+        return litGlass;
+    if (value < 8)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+const base = (n) => 37.1 + (n - 9) * 3.85;
+const rows = [
+    { lo: 0.25, hi: drawn(1), kind: "wall", floor: 1 },
+    { lo: drawn(1), hi: drawn(9), kind: "glass", floor: 1 },
+];
+const push = (hi, kind, floor) => rows.push({ lo: rows.at(-1).hi, hi, kind, floor });
+for (let n = 2; n <= 15; n += 1) {
+    push(drawn(base(n) + 0.6), "wall", n);
+    push(drawn(base(n) + 3.1), "glass", n);
+}
+push(drawn(64.5), "wall", 16);
+push(drawn(65.9), "glass", 16);
+push(drawn(66.5), "head", 16);
+push(drawn(68.6), "wall", 17);
+push(drawn(69.6), "glass", 17);
+push(h.cornice, "wall", 17);
+push(h.top, "band", 17);
+export function createLakeViewGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Lake View Building · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Lake View Building · stone and windows", kit.material(0xffffff, { vertexColors: true }));
+    const lot = orient(polygonOf(projectPlan(record.footprint.coordinates)));
+    // The lot's south-east corner, with its south wall running west and its Michigan front
+    // north to the MacLean Center.
+    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 neighbours = [lot[(lot.indexOf(corner) + 1) % lot.length], lot[(lot.indexOf(corner) + lot.length - 1) % lot.length]];
+    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(neighbours[0][0] < neighbours[1][0] ? neighbours[0] : neighbours[1]), north = unit(northEast);
+    // 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 front = inLot(northEast)[1];
+    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);
+    // A wall's skin, one box to a chain the `keep` test accepts, held 2 cm clear of its ends
+    // or 9 cm where the outline turns in. `openings` lays a wall's columns out across it and
+    // says which cross a window's side (1) or its middle (2), which alone continues into an
+    // arched head. Only a `banded` wall carries the cornice band.
+    const skin = (seed, keep, openings, banded = false) => {
+        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, crossing] = 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], into = crossing(bay);
+                if (row.kind === "band")
+                    return banded ? band : stone;
+                return (row.kind === "glass" && into >= 1) || (row.kind === "head" && into >= 2) ? paneColor(row.floor, bay, seed * 8 + index) : stone;
+            }, stone);
+        });
+    };
+    // Windows `width` wide at `centres`, positions along a wall from its start, each split
+    // into sides and a middle half.
+    const windows = (length, centres, width) => {
+        const inside = centres.filter((c) => c - width / 2 > 0.1 && c + width / 2 < length - 0.1).sort((p, q) => p - q);
+        const columns = [0, ...inside.flatMap((c) => [c - width / 2, c - width / 4, c + width / 4, c + width / 2]), length];
+        // Bays count from one: a pier, then side, middle, side for each window, then the last pier.
+        return [columns, (bay) => { const k = (bay - 1) % 4; return bay > 4 * inside.length || k === 0 ? 0 : k === 2 ? 2 : 1; }];
+    };
+    // The Michigan front's three windows, 2.5 m wide and 3.5 m apart about its middle, as
+    // drawn; the alley's, which the drawing does not show, 1.6 m wide and spread evenly about
+    // 3 m apart.
+    const michigan = (length, start, end) => {
+        const [b0, b1] = [inLot(start)[1], inLot(end)[1]], along = (b) => length * (b - b0) / (b1 - b0);
+        return windows(length, [-3.5, 0, 3.5].map((d) => along(front / 2 + d)), 2.5);
+    };
+    const alley = (length) => {
+        const count = Math.max(1, Math.round(length / 3.2)), [columns, crossing] = windows(length, Array.from({ length: count }, (_, k) => length * (k + 0.5) / count), 1.6);
+        return [columns, (bay) => Math.min(1, crossing(bay))];
+    };
+    // The Michigan front and the alley by their facing and their place in the lot; the side
+    // walls, shared with the taller MacLean Center and Peoples Gas, and the south light
+    // court's walls stay plain. The cornice band runs only along Michigan.
+    const facing = (x, z) => (run) => run.normal(0)[0] * x + run.normal(0)[1] * z > 0.9;
+    const isMichigan = (run) => facing(1, 0)(run) && inLot(run.at(run.length / 2))[0] < 1;
+    const isAlley = (run) => facing(-1, 0)(run) && inLot(run.at(run.length / 2))[0] > 40;
+    skin(0, isMichigan, michigan, true);
+    skin(1, isAlley, alley);
+    skin(2, (run) => !isMichigan(run) && !isAlley(run), (length) => [[0, length], () => 0]);
+    const model = kit.finish({ height: h.top, outlines: [shell], 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/lake-view-reference.md" };
+    return model;
+}

package/site/models/maclean-center-geographic.js

@@ -0,0 +1,162 @@
+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 MacLean Center, 112 South Michigan Avenue, built as the Illinois Athletic Club
+// (Barnett, Haynes & Barnett, 1908) and raised six floors by Swann & Weiskopf in 1985: the
+// geographic layout's model, on the mapped outline 145498712. The original layout has no
+// model of it; the drawing shows it between the Lake View and Monroe Buildings.
+//
+// A narrow Michigan front, a narrow window and three wide ones to a floor and another
+// narrow one, each section at its drawn widths, rises twelve storeys to the old club's
+// projecting cornice and a frieze of round windows; the addition carries six more floors,
+// arched on the top one, to a pierced parapet. The parapet's top is the Skyscraper Center's
+// 77.4 m. The drawn parapet reads 73.8 m, so heights read on the drawing are scaled to meet
+// it; see docs/maclean-center-reference.md. Units are meters; +x is east, +z is south.
+const drawn = (height) => height * 77.4 / 73.8;
+export const macleanLevels = Object.freeze({
+    band: drawn(40.9), // the old club's bands under its cornice
+    cornice: drawn(43.8), // the projecting cornice
+    frieze: drawn(45.6), // the frieze of round windows
+    addition: drawn(48.5), // the 1985 floors, over the frieze
+    openings: drawn(70.9), // the parapet's openings
+    parapet: drawn(72.6), // its top band
+    top: 77.4, // the parapet's top, the published height
+});
+const h = macleanLevels;
+// The skins' colours: the window tones, and the stone, bands and the parapet's shadowed
+// openings, which no window shares.
+export const macleanPalette = Object.freeze({ glass: [0x2c2c2c, 0x303030, 0x343434, 0x383838], lit: 0x6e6e6e, dim: 0x3c3c3c, stone: 0x7e7e7e, band: 0x8e8e8e, shadow: 0x242424 });
+const palette = macleanPalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim);
+const stone = color(palette.stone), band = color(palette.band), shadow = color(palette.shadow);
+const core = color(0x262626), roofing = color(0x3c3c3c);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 53, 0x9e3779b1) ^ Math.imul(bay + 79, 0x85ebca77) ^ Math.imul(wall + 67, 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: drawn(1), kind: "wall", floor: 1 },
+    { lo: drawn(1), hi: drawn(4.5), kind: "glass", floor: 1 },
+];
+const push = (hi, kind, floor, dy) => rows.push({ lo: rows.at(-1).hi, hi, kind, floor, ...(dy === undefined ? {} : { dy }) });
+for (let n = 2; n <= 12; n += 1) {
+    const base = 5.1 + (n - 2) * 3.2;
+    push(drawn(base + 0.6), "wall", n);
+    push(drawn(base + 3.1), "glass", n);
+}
+push(h.band, "wall", 12);
+push(h.frieze, "band", 12);
+push(drawn(46.5), "wall", 12);
+// The round windows, 90 cm across and centred at 46.95 m as drawn, in five slices, each
+// carrying its middle's drawn height from the centre.
+for (const [lo, hi] of [[46.5, 46.65], [46.65, 46.85], [46.85, 47.05], [47.05, 47.25], [47.25, 47.4]])
+    push(drawn(hi), "oculus", 12, Math.abs((lo + hi) / 2 - 46.95));
+push(h.addition, "wall", 12);
+for (const [floor, lo, hi] of [[13, 49.06, 51.48], [14, 52.17, 54.72], [15, 55.98, 58.54], [16, 59.67, 62.21], [17, 63.37, 65.92], [18, 66.7, 68.23]]) {
+    push(drawn(lo), "wall", floor);
+    push(drawn(hi), "glass", floor);
+}
+push(drawn(68.83), "head", 18);
+push(h.openings, "wall", 18);
+rows.push({ lo: h.openings, hi: h.parapet, kind: "opening", floor: 18 });
+rows.push({ lo: h.parapet, hi: h.top, kind: "wall", floor: 18 });
+export function createMacleanCenterGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("MacLean Center · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("MacLean Center · stone and windows", kit.material(0xffffff, { vertexColors: true }));
+    const cornice = kit.batch("MacLean Center · cornice", kit.material(0x8a8a8a));
+    const lot = orient(polygonOf(projectPlan(record.footprint.coordinates)));
+    // The lot's south-east corner, with its south wall running west and its Michigan front
+    // north to the Monroe Building.
+    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 neighbours = [lot[(lot.indexOf(corner) + 1) % lot.length], lot[(lot.indexOf(corner) + lot.length - 1) % lot.length]];
+    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(neighbours[0][0] < neighbours[1][0] ? neighbours[0] : neighbours[1]), 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 front = inLot(northEast)[1];
+    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 old club's cornice projects 60 cm along the Michigan front, 3 cm short of the
+    // neighbours' walls, past the skin's ends 2 cm in, and 5 cm into its own.
+    kit.prism(cornice, planOf(rect(-0.6, 0.05, 0.03, front - 0.03)), [h.cornice, h.frieze]);
+    const skin = (seed, keep, openings, plain = false) => {
+        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, cell] = 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];
+                if (row.kind === "band")
+                    return plain ? stone : band;
+                const shows = cell(bay, row);
+                return shows === "glass" ? paneColor(row.floor, bay, seed * 8 + index) : shows === "shadow" ? shadow : stone;
+            }, stone);
+        });
+    };
+    // The Michigan front's five columns, narrow windows 8.4 m either side of the middle and
+    // wide ones at the middle and 4.35 m either side, with each section's widths as drawn: the
+    // old club's windows 1.4 and 2.36 m wide, the addition's 2 and 3.15 m, and the parapet's
+    // openings 2.9 m. Only the wide columns have arched heads, their middle half, and round
+    // windows over them.
+    const michigan = (length, start, end) => {
+        const [b0, b1] = [inLot(start)[1], inLot(end)[1]], along = (b) => length * (b - b0) / (b1 - b0), middle = front / 2;
+        const windows = [[-8.4, false], [-4.35, true], [0, true], [4.35, true], [8.4, false]].map(([d, wide]) => ({ c: along(middle + d), wide }));
+        const halves = (wide) => (wide ? [0.25, 0.42, 0.45, 0.79, 1.18, 1.45, 1.575] : [0.7, 1, 1.45]);
+        const cuts = windows.flatMap(({ c, wide }) => halves(wide).flatMap((half) => [c - half, c + half]));
+        const columns = [0, ...[...new Set(cuts)].sort((p, q) => p - q), length];
+        return [columns, (bay, row) => {
+                const middleOf = (columns[bay - 1] + columns[bay]) / 2, window = windows.find(({ c, wide }) => Math.abs(middleOf - c) < (wide ? 1.575 : 1.45));
+                if (!window)
+                    return "wall";
+                const dx = Math.abs(middleOf - window.c), wide = window.wide, old = row.floor <= 12;
+                if (row.kind === "glass")
+                    return dx < (wide ? (old ? 1.18 : 1.575) : (old ? 0.7 : 1)) ? "glass" : "wall";
+                if (row.kind === "head")
+                    return wide && dx < 0.79 ? "glass" : "wall";
+                if (row.kind === "oculus")
+                    return wide && dx * dx + row.dy * row.dy <= 0.45 * 0.45 ? "glass" : "wall";
+                if (row.kind === "opening")
+                    return dx < 1.45 ? "shadow" : "wall";
+                return "wall";
+            }];
+    };
+    // The alley's windows, 1.6 m wide every 3.2 m.
+    const alley = (length) => {
+        const count = Math.max(1, Math.round(length / 3.2)), centres = Array.from({ length: count }, (_, k) => length * (k + 0.5) / count);
+        return [[0, ...centres.flatMap((c) => [c - 0.8, c + 0.8]), length], (bay, row) => (row.kind === "glass" && bay % 2 === 0 && bay <= 2 * count ? "glass" : "wall")];
+    };
+    const facing = (x, z) => (run) => run.normal(0)[0] * x + run.normal(0)[1] * z > 0.9;
+    // The bands run only along Michigan; the side walls are shared with the Lake View and
+    // Monroe Buildings and stay plain.
+    skin(0, facing(1, 0), michigan);
+    skin(1, facing(-1, 0), alley, true);
+    skin(2, (run) => !facing(1, 0)(run) && !facing(-1, 0)(run), (length) => [[0, length], () => "wall"], true);
+    const model = kit.finish({ height: h.top, outlines: [shell, cornice], 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/maclean-center-reference.md" };
+    return model;
+}

package/site/models/michigan-boulevard-geographic.js

@@ -0,0 +1,157 @@
+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 Michigan Boulevard Building, 30 North Michigan Avenue (Jarvis Hunt, 1914, fifteen
+// storeys; six added by Hunt in 1923): the geographic layout's model, on the mapped outline
+// 126982630. The original layout has no model of it; the drawing shows its Michigan front
+// and, above 20 North Michigan, its south wall, right of Six North Michigan's tower.
+//
+// A terracotta street front of five bays, a single window and four pairs to a floor, over
+// twenty-one storeys, with a belt course over the thirteenth and an attic of panels under a
+// parapet at the published 82 m. The terracotta turns one bay onto the south wall; beyond
+// it the wall is common brick, shared with 20 North Michigan to its eighth floor and blank
+// to the eighteenth. Heights are measured on the drawing down from that top; see
+// docs/michigan-boulevard-reference.md. Units are meters; +x is east, +z is south.
+export const michiganBoulevardLevels = Object.freeze({
+    belt: 49, // the belt course over the thirteenth floor
+    beltTop: 50.2,
+    attic: 78.16, // the attic, over the twenty-first floor's windows
+    top: 82, // the parapet, the published height
+    endParapet: 83.3, // the raised parapet over the front's south bay
+    pedestals: 82.6, // the pedestals over the front's piers
+    returnBay: 5.6, // the terracotta's return onto the south wall
+});
+const h = michiganBoulevardLevels;
+// Each floor's level: a 4.8 m ground floor, 3.7 m floors to the thirteenth, which the belt
+// course makes 4.7 m, and 3.58 m floors above.
+const floor = (n) => (n < 2 ? 0 : n <= 13 ? 4.8 + (n - 2) * 3.7 : 50.2 + (n - 14) * 3.58);
+const color = (hex) => new THREE.Color(hex);
+const glassTones = [0x262626, 0x2a2a2a, 0x2e2e2e, 0x323232].map(color);
+const litGlass = color(0x6e6e6e), dimGlass = color(0x3a3a3a);
+const terracotta = color(0x444444), returnBay = color(0x585858), brick = color(0x404040), belt = color(0x505050), panel = color(0x363636);
+const core = color(0x262626), roofing = color(0x3a3a3a);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 37, 0x9e3779b1) ^ Math.imul(bay + 61, 0x85ebca77) ^ Math.imul(wall + 47, 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: 4.2, kind: "glass", floor: 1 },
+];
+for (let n = 2; n <= 21; n += 1) {
+    const below = rows.at(-1).hi;
+    if (n === 14) {
+        rows.push({ lo: below, hi: h.belt, kind: "wall", floor: n });
+        rows.push({ lo: h.belt, hi: h.beltTop, kind: "belt", floor: n });
+        rows.push({ lo: h.beltTop, hi: floor(n) + 0.9, kind: "wall", floor: n });
+    }
+    else
+        rows.push({ lo: below, hi: floor(n) + 0.9, kind: "wall", floor: n });
+    rows.push({ lo: floor(n) + 0.9, hi: floor(n) + 2.9, kind: "glass", floor: n });
+}
+rows.push({ lo: h.attic, hi: 79.2, kind: "attic", floor: 22 });
+rows.push({ lo: 79.2, hi: 80.9, kind: "panel", floor: 22 });
+rows.push({ lo: 80.9, hi: h.top, kind: "attic", floor: 22 });
+export function createMichiganBoulevardGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Michigan Boulevard Building · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Michigan Boulevard Building · terracotta and windows", kit.material(0xffffff, { vertexColors: true }));
+    const parapets = kit.batch("Michigan Boulevard Building · parapet", kit.material(0x4c4c4c));
+    const lot = orient(polygonOf(projectPlan(record.footprint.coordinates)));
+    // The lot's south-east corner, with its south wall running west and its Michigan front
+    // north to the Washington Street corner.
+    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 neighbours = [lot[(lot.indexOf(corner) + 1) % lot.length], lot[(lot.indexOf(corner) + lot.length - 1) % lot.length]];
+    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(neighbours[0][0] < neighbours[1][0] ? neighbours[0] : neighbours[1]), 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 front = inLot(northEast)[1];
+    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);
+    // Over the front's south bay the parapet rises, and pedestals stand over the piers between
+    // the pairs and at the Washington corner, 5 cm inside the walls' planes.
+    kit.prism(parapets, planOf(rect(0.05, 0.65, 0.05, 6.2)), [h.top, h.endParapet]);
+    for (const b of [12.4, 18.5, 24.6, front - 0.45])
+        kit.prism(parapets, planOf(rect(0.05, 0.65, b - 0.4, b + 0.4)), [h.top, h.pedestals]);
+    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, window, from, panel: paneled } = column(bay);
+                if (row.kind === "belt")
+                    return face === brick ? brick : belt;
+                if (row.kind === "panel")
+                    return paneled ? panel : face;
+                return row.kind === "glass" && window && row.floor >= from ? paneColor(row.floor, bay, seed * 8 + index) : face;
+            }, terracotta);
+        });
+    };
+    // A position along a wall from its start, given in lot coordinates across it, and back.
+    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 `width` wide centred at `centres`, in lot coordinates along `axis`, with the
+    // walls also split at `breaks`; `column` says, in the same coordinates, what else each
+    // column carries.
+    const windows = (length, start, end, axis, centres, width, column, breaks = []) => {
+        const [to, from] = along(length, start, end, axis);
+        const inside = centres.map(to).filter((c) => c - width / 2 > 0.1 && c + width / 2 < length - 0.1);
+        const cuts = [...inside.flatMap((c) => [c - width / 2, c + width / 2]), ...breaks.map(to).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.
+        return [columns, (bay) => {
+                const middle = (columns[bay - 1] + columns[bay]) / 2;
+                return { ...column(from(middle)), window: inside.some((c) => Math.abs(middle - c) < width / 2) };
+            }];
+    };
+    const pairs = (centres) => centres.flatMap((c) => [c - 1, c + 1]);
+    const facing = (x, z) => (run) => run.normal(0)[0] * x + run.normal(0)[1] * z > 0.9;
+    const [isMichigan, isSouth, isWashington] = [facing(1, 0), facing(0, 1), facing(0, -1)];
+    // The Michigan front: a single window in its south bay and a pair in each of the other
+    // four, 2 m apart; the attic's panel spans each bay's windows.
+    const frontBays = [[3.1, 0.725], ...[9.3, 15.45, 21.55, 27.75].map((c) => [c, 1.725])];
+    const michigan = (length, start, end) => windows(length, start, end, 1, [3.1, ...pairs([9.3, 15.45, 21.55, 27.75])], 1.45, (b) => ({ face: terracotta, from: 1, panel: frontBays.some(([c, half]) => Math.abs(b - c) < half) }));
+    // The south wall: the terracotta's return bay with a pair of windows over 20 North
+    // Michigan, then brick with a pair every 5.1 m on the top four floors, as drawn.
+    const southWall = (length, start, end) => windows(length, start, end, 0, pairs([2.5, 8, 13.2, 18.3, 23.4, 28.5, 33.6, 38.7, 43.8]), 1.1, (a) => (a < h.returnBay ? { face: returnBay, from: 9, panel: false } : { face: brick, from: 18, panel: false }), [h.returnBay]);
+    // Washington Street's terracotta front and the brick alley: a pair every 6.1 m.
+    const rear = (face) => (length, start, end) => {
+        const axis = Math.abs(inLot(end)[0] - inLot(start)[0]) > Math.abs(inLot(end)[1] - inLot(start)[1]) ? 0 : 1, [, from] = along(length, start, end, axis);
+        const count = Math.max(1, Math.round(length / 6.1));
+        return windows(length, start, end, axis, pairs(Array.from({ length: count }, (_, i) => from(length * (i + 0.5) / count))), 1.1, () => ({ face, from: 1, panel: false }));
+    };
+    skin(0, isMichigan, michigan);
+    skin(1, isSouth, southWall);
+    skin(2, isWashington, rear(terracotta));
+    skin(3, (run) => !isMichigan(run) && !isSouth(run) && !isWashington(run), rear(brick));
+    const model = kit.finish({ height: h.endParapet, outlines: [shell, parapets], 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/michigan-boulevard-reference.md" };
+    return model;
+}

package/site/models/michigan-plaza-south-geographic.js

@@ -0,0 +1,84 @@
+import { createBuilder } from "./building-kit.js";
+// Michigan Plaza South at 205 North Michigan Avenue: the geographic layout's
+// detailed model. The mapped ground outline stays exact; the 168.6 m top is
+// the published architectural height. The dark curtain-wall grid, recessed
+// panes with scattered lit units, and pale mullions reuse the fitted model's
+// vocabulary at meter scale. Window-row and bay spacings are estimates; see
+// docs/michigan-plaza-south-geographic-reference.md. Units are meters; +x is
+// east, +z is south.
+export const michiganPlazaSouthGeographicLevels = Object.freeze({
+    roof: 168.6, // published architectural height
+    floors: 44,
+});
+const h = michiganPlazaSouthGeographicLevels;
+const shaftTop = h.roof - 0.8;
+const pitch = shaftTop / h.floors;
+export function createMichiganPlazaSouthGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    // The neutral palette of the fitted model: a mid-gray frame grid over dark
+    // glazing with scattered lit panes.
+    const shell = kit.batch("Michigan Plaza South · mapped tower shell", kit.material(0x555555));
+    const mullions = kit.batch("Michigan Plaza South · mullions and bands", kit.material(0x7a7a7a));
+    const lit = kit.batch("Michigan Plaza South · lit glazing", kit.material(0x5a5a5a));
+    const dim = kit.batch("Michigan Plaza South · dim glazing", kit.material(0x464646));
+    const tones = [0x2a2a2a, 0x2e2e2e, 0x333333, 0x262626].map((color, i) => kit.batch(`Michigan Plaza South · glazing ${i + 1}`, kit.material(color)));
+    const paneTone = (row, bay, side) => {
+        const hash = (Math.imul(row + 5, 0x9e3779b1) ^ Math.imul(bay + 17, 0x85ebca77) ^ Math.imul(side + 3, 0xc2b2ae3d)) >>> 0;
+        const value = hash % 97;
+        if (value < 3)
+            return lit;
+        if (value < 6)
+            return dim;
+        return tones[value % tones.length];
+    };
+    const ground = projectPlan(record.footprint.coordinates);
+    // The mapped volume: the outline itself is the tower, with a roof parapet.
+    kit.prism(shell, ground, [0, shaftTop]);
+    // A closed shallow solid on a run. Offsets separate the visible surfaces from
+    // their backing wall, and the ends stop short of polygon corners so adjacent
+    // walls' projecting returns cannot overlap at the same elevation.
+    const strip = (batch, run, from, to, y0, y1, back, front) => {
+        const clearance = Math.max(Math.abs(back), Math.abs(front)) + 0.025;
+        from = Math.max(from, clearance);
+        to = Math.min(to, run.length - clearance);
+        if (to - from < 0.03 || y1 <= y0)
+            return;
+        kit.box(batch, run.at((from + to) / 2), run.normal(0), (to - from) / 2, back, front, y0, y1);
+    };
+    // The dense Miesian grid: one pane per bay per row between full-height
+    // mullions, with a pale base course at grade. Mullions stand proudest.
+    ground.forEach((run, side) => {
+        if (run.length < 2)
+            return;
+        const bays = Math.max(1, Math.round(run.length / 3.1));
+        const width = run.length / bays;
+        for (let row = 1; row <= h.floors; row += 1) {
+            const bottom = Math.max((row - 1) * pitch, 0.85), top = row * pitch;
+            for (let bay = 0; bay < bays; bay += 1) {
+                strip(paneTone(row, bay, side), run, bay * width + 0.18, (bay + 1) * width - 0.18, bottom + 0.28, top - 0.24, 0.03, 0.07);
+            }
+        }
+        for (let i = 0; i <= bays; i += 1) {
+            const s = Math.max(0.18, Math.min(run.length - 0.18, i * width));
+            strip(mullions, run, s - 0.06, s + 0.06, 0.25, shaftTop - 0.05, 0.05, 0.16);
+        }
+        strip(mullions, run, 0.015, run.length - 0.015, 0.3, 0.75, 0.06, 0.18);
+    });
+    // The roof parapet wraps the mapped outline at the published 168.6 m top.
+    // The outline's notch has concave corners, which a closed band cannot turn,
+    // so the parapet is per-segment boxes that stop short of every corner.
+    ground.forEach((run) => {
+        if (run.length < 2)
+            return;
+        const count = Math.max(1, Math.ceil(run.length / 1.5));
+        for (let index = 0; index < count; index += 1) {
+            const from = index * run.length / count, to = (index + 1) * run.length / count;
+            strip(mullions, run, from, to, shaftTop, h.roof, 0.05, 0.35);
+        }
+    });
+    const model = kit.finish({ height: h.roof, outlines: [shell, mullions], opacity: 0.16 });
+    model.building.position.set(offset[0], 0, offset[1]);
+    model.building.userData["geography"] = record;
+    model.building.userData["geographicDetail"] = { levels: h, floors: 44, source: "docs/michigan-plaza-south-geographic-reference.md" };
+    return model;
+}

package/site/models/michigan-plaza-south.js

@@ -0,0 +1,68 @@
+import * as THREE from "../vendor/three-r186.js";
+// The roof outline and visible window spacing follow the source SVG. The
+// footprint, hidden faces, and lower floors obscured in the drawing are inferred.
+export function createMichiganPlazaSouthBuilding() {
+    const building = new THREE.Group();
+    building.name = "Michigan Plaza South";
+    building.userData["buildingId"] = "building-michigan-plaza-south-tower";
+    const width = 46.7, depth = 46.7, height = 180;
+    const gradient = new THREE.DataTexture(new Uint8Array([90, 145, 205, 255]), 4, 1, THREE.RedFormat);
+    gradient.minFilter = gradient.magFilter = THREE.NearestFilter;
+    gradient.needsUpdate = true;
+    const material = (color) => new THREE.MeshToonMaterial({ color, gradientMap: gradient });
+    const frame = material(0x555555);
+    const glass = material(0x323232);
+    const recess = material(0x252525);
+    const materials = [frame, glass, recess];
+    let triangleCount = 0;
+    function box(name, size, position, surface) {
+        const mesh = new THREE.Mesh(new THREE.BoxGeometry(...size), surface);
+        mesh.name = name;
+        mesh.position.set(...position);
+        mesh.castShadow = mesh.receiveShadow = true;
+        building.add(mesh);
+        triangleCount += 12;
+    }
+    box("closed tower shell", [width, height, depth], [0, height / 2, 0], frame);
+    box("inset flat roof", [width - 1, 0.15, depth - 1], [0, height + 0.025, 0], recess);
+    const windows = [], reveals = [];
+    const quad = (positions, a, b, c, d) => {
+        for (const point of [a, b, c, a, c, d])
+            positions.push(...point);
+    };
+    const corners = [[-width / 2, depth / 2], [width / 2, depth / 2], [width / 2, -depth / 2], [-width / 2, -depth / 2]];
+    for (let face = 0; face < 4; face += 1) {
+        const a = corners[face], b = corners[(face + 1) % 4];
+        const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        const normal = [(a[1] - b[1]) / length, (b[0] - a[0]) / length];
+        const point = (t, y, offset) => [a[0] + (b[0] - a[0]) * t + normal[0] * offset, y, a[1] + (b[1] - a[1]) * t + normal[1] * offset];
+        // Match the 24- and 23-column grids drawn on the two visible SVG faces.
+        const columns = face % 2 === 0 ? 24 : 23;
+        for (let row = 0; row < 40; row += 1) {
+            const top = height - 13 - row * 4.1;
+            const bottom = top - 2.7;
+            for (let column = 0; column < columns; column += 1) {
+                const left = (column + 0.22) / columns, right = (column + 0.88) / columns;
+                // A dark surround and offset pane separate each opening without
+                // allocating thousands of individual meshes or external textures.
+                quad(reveals, point(left - 0.002, bottom - 0.08, 0.025), point(right + 0.002, bottom - 0.08, 0.025), point(right + 0.002, top + 0.08, 0.025), point(left - 0.002, top + 0.08, 0.025));
+                quad(windows, point(left, bottom, 0.055), point(right, bottom, 0.055), point(right, top, 0.055), point(left, top, 0.055));
+            }
+        }
+    }
+    for (const [name, positions, surface] of [["window surrounds", reveals, recess], ["window grid", windows, glass]]) {
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+        geometry.computeVertexNormals();
+        const mesh = new THREE.Mesh(geometry, surface);
+        mesh.name = name;
+        mesh.castShadow = mesh.receiveShadow = true;
+        building.add(mesh);
+        triangleCount += positions.length / 9;
+    }
+    return {
+        building, height, triangleCount,
+        setHighlighted(highlighted) { materials.forEach((surface) => surface.emissive.setHex(highlighted ? 0x222222 : 0)); },
+        setWireframe(enabled) { materials.forEach((surface) => { surface.wireframe = enabled; }); },
+    };
+}