@a2f0/skyline 0.0.0-stage → 0.1.1

package/lib/models/aon-tower.d.ts

@@ -0,0 +1,23 @@
+import type { BuildingModel, Vec2 } from "./building-kit.js";
+export interface AonForm {
+    name: string;
+    id: string;
+    outline: Vec2[];
+    enclosure: Vec2[];
+    mast: Vec2;
+    base: number;
+}
+export declare const aonLevels: Readonly<{
+    roof: 340;
+    capBottom: 338.5;
+    lobbyTop: 11.9;
+    pitch: 3.87;
+    sill: 0.8;
+    head: 3.1;
+    enclosureTop: 346.3;
+    tip: 362.5;
+    bay: 3.048;
+    baysPerFace: 15;
+    faceLength: 20;
+}>;
+export declare function buildAonTower(form: AonForm): BuildingModel;

package/lib/models/aon-tower.js

@@ -0,0 +1,130 @@
+import * as THREE from "../vendor/three-r186.js";
+import { createBuilder, line } from "./building-kit.js";
+import { chainsOf, gridBox, mitredBox, orient, paintedSlab, planOf, turnAt } from "./facade-grid.js";
+// Heights above the street. The floor pitch and the cap are measured on the photograph the
+// drawing was traced from. The lobby takes what is left below eighty office floors and the
+// two mechanical floors over them, which with the lobby make the published 83; daylight
+// photographs show the slots unchanged over the mechanical floors, so the glass keeps the
+// office floors' pitch up to the cap.
+export const aonLevels = Object.freeze({
+    roof: 340,
+    capBottom: 338.5,
+    lobbyTop: 11.9,
+    pitch: 3.87,
+    sill: 0.8,
+    head: 3.1,
+    enclosureTop: 346.3,
+    tip: 362.5,
+    bay: 3.048, // nominal clean-plan module; mapped spacing follows each face's chord
+    baysPerFace: 15, // tenant portal's Suite 1300 plan: sixteen piers, fifteen openings
+    faceLength: 20,
+});
+const h = aonLevels;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = [0x262626, 0x2c2c2c, 0x323232, 0x222222].map(color);
+const litGlass = color(0x7c7c7c), dimGlass = color(0x4e4e4e);
+const spandrel = color(0x1b1b1b), granite = color(0xb2b2b2), core = color(0x202020);
+const slat = color(0x9c9c9c), slatGap = color(0x444444), roofing = color(0x4c4c4c);
+function paneColor(row, bay, face) {
+    const hash = (Math.imul(row + 17, 0x9e3779b1) ^ Math.imul(bay + 31, 0x85ebca77) ^ Math.imul(face + 7, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 3)
+        return litGlass;
+    if (value < 6)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+export function buildAonTower(form) {
+    const kit = createBuilder(form.name, form.id);
+    const shell = kit.batch("Aon · tube shell", kit.material(0xffffff, { vertexColors: true }));
+    const glazing = kit.batch("Aon · window ribbons", kit.material(0xffffff, { vertexColors: true }));
+    const piers = kit.batch("Aon · granite piers", kit.material(0xbababa));
+    const cap = kit.batch("Aon · granite cap", kit.material(0xc4c4c4));
+    const enclosure = kit.batch("Aon · rooftop enclosure", kit.material(0xffffff, { vertexColors: true }));
+    const mast = kit.batch("Aon · antenna mast", kit.material(0x6a6a6a));
+    const base = form.base;
+    const y = (real) => real - base;
+    const outline = orient(form.outline), plan = planOf(outline);
+    // A traced outline can split one face into nearly collinear pieces, which chainsOf joins
+    // within 5°: a chain at least `faceLength` long is a main face, whose facade stands on its
+    // chord, and every other run belongs to a notched corner.
+    const faces = chainsOf(plan).map(({ runs }) => ({ chord: line(plan[runs[0]].at(0), plan[runs.at(-1)].at(plan[runs.at(-1)].length)), runs })).filter(({ chord }) => chord.length >= h.faceLength);
+    const onFace = new Set(faces.flatMap(({ runs }) => runs));
+    const grid = (target, run, columns, rows, back, front, paint, sides) => gridBox(kit, target, run, columns, rows, back, front, paint, sides, y);
+    // The shaft: dark spandrel walls on the faces, granite on the notched corners, a floor,
+    // and the flat roof.
+    plan.forEach((run, index) => {
+        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], y(h.roof), b[1]], [a[0], y(h.roof), a[1]]], [[n[0], 0, n[1]]], onFace.has(index) ? core : granite);
+    });
+    paintedSlab(kit, shell, outline, 0, false, roofing);
+    paintedSlab(kit, shell, outline, y(h.roof), true, roofing);
+    // The source plan fixes fifteen openings per face, independent of an OSM trace's
+    // corner depth. Distribute them over each face's chord; mapped spacing remains an
+    // approximation (docs/aon-reference.md, FID-AON-001). End piers stay on their face.
+    const faceBays = (run) => {
+        const count = h.baysPerFace, bay = run.length / count;
+        return Array.from({ length: count + 1 }, (_, i) => i * bay);
+    };
+    const pierHalf = 0.65, pierPoint = 0.7;
+    const floors = [];
+    for (let level = h.lobbyTop; level + h.pitch <= h.capBottom + 1e-6; level += h.pitch)
+        floors.push(level);
+    faces.forEach(({ chord: run }, face) => {
+        const stations = faceBays(run);
+        // End piers are inset from the corner. Stop glass at their centres so it
+        // cannot peek past the taper of the V and create two extra narrow slots.
+        const glassStations = [pierHalf, ...stations.slice(1, -1), run.length - pierHalf];
+        // The glass: one ribbon per floor across the face, cut into panes at the columns, which
+        // stand in front of the joints. The lobby is a single tall storey of glass.
+        const visible = (low) => low >= base;
+        if (visible(0.4))
+            grid(glazing, run, glassStations, [0.4, h.lobbyTop - 0.9], 0.02, 0.07, (bay) => paneColor(0, bay, face), spandrel);
+        floors.forEach((level, row) => {
+            if (!visible(level + h.sill))
+                return;
+            grid(glazing, run, glassStations, [level + h.sill, level + h.head], 0.02, 0.07, (bay) => paneColor(row + 1, bay, face), spandrel);
+        });
+        // The V-shaped columns: granite prisms from just above grade to the cap, their points
+        // outward. They start 0.3 m up so their relief leaves the street outline unchanged.
+        for (const station of stations) {
+            const s = Math.min(Math.max(station, pierHalf), run.length - pierHalf);
+            const [left, right, point] = [run.at(s - pierHalf, 0), run.at(s + pierHalf, 0), run.at(s, pierPoint)];
+            const low = y(Math.max(base, 0.3)), high = y(h.capBottom);
+            const up = [0, 1, 0], down = [0, -1, 0];
+            const p = (q, v) => [q[0], v, q[1]];
+            // Outward is to the right of a and then b, as it is for every run of the plan.
+            const faceOf = (a, b) => { const d = [b[0] - a[0], b[1] - a[1]], l = Math.hypot(...d); return [-d[1] / l, 0, d[0] / l]; };
+            kit.quad(piers, [p(left, low), p(point, low), p(point, high), p(left, high)], [faceOf(left, point)]);
+            kit.quad(piers, [p(point, low), p(right, low), p(right, high), p(point, high)], [faceOf(point, right)]);
+            kit.quad(piers, [p(right, low), p(left, low), p(left, high), p(right, high)], [[-run.normal(0)[0], 0, -run.normal(0)[1]]]);
+            kit.triangle(piers, [p(left, high), p(point, high), p(right, high)], [up, up, up]);
+            kit.triangle(piers, [p(left, low), p(right, low), p(point, low)], [down, down, down]);
+        }
+    });
+    // The granite cap: a fascia under the roof edge on every run, standing clear of the
+    // columns' points and mitred on the bisector of each corner.
+    const capWidth = pierPoint + 0.2;
+    if (h.roof > base)
+        plan.forEach((run, index) => {
+            mitredBox(kit, cap, run, 0, run.length, turnAt(plan[(index + plan.length - 1) % plan.length], run), turnAt(run, plan[(index + 1) % plan.length]), capWidth, h.capBottom, h.roof, y);
+        });
+    // The rooftop enclosure: louvered walls from the roof to the published top, and a lid.
+    const enclosureOutline = orient(form.enclosure);
+    planOf(enclosureOutline).forEach((run) => {
+        const rows = [];
+        for (let v = h.roof; v < h.enclosureTop - 1e-6; v += 0.6)
+            rows.push(v);
+        rows.push(h.enclosureTop);
+        const a = run.at(0), b = run.at(run.length), n = run.normal(0);
+        // Its walls are cells of blades and gaps, so the enclosure closes on its own lid and floor.
+        const at = (q, v) => [q[0], y(v), q[1]];
+        for (let r = 0; r + 1 < rows.length; r += 1)
+            kit.quad(enclosure, [at(a, rows[r]), at(b, rows[r]), at(b, rows[r + 1]), at(a, rows[r + 1])], [[n[0], 0, n[1]]], r % 2 === 0 ? slat : slatGap);
+    });
+    paintedSlab(kit, enclosure, enclosureOutline, y(h.roof), false, roofing);
+    paintedSlab(kit, enclosure, enclosureOutline, y(h.enclosureTop), true, roofing);
+    // The antenna: a slim mast from the enclosure to the published tip.
+    kit.box(mast, form.mast, [0, 1], 0.3, -0.3, 0.3, y(h.enclosureTop), y(h.tip));
+    return kit.finish({ height: y(h.tip), outlines: [shell, cap], opacity: 0.18 });
+}

package/lib/models/blue-cross-geographic.d.ts

@@ -0,0 +1,14 @@
+import type { BuildingModel, Plan } from "./building-kit.js";
+import type { GeoBuilding } from "./skyline-geography-data.js";
+export declare const blueCrossLevels: Readonly<{
+    lobbyTop: 10.26;
+    bands: readonly [readonly [65.7, 72.1], readonly [117.1, 128.1], readonly [170.1, 176.6]];
+    occupied: 208.3;
+    roof: 212.8;
+    wings: 212;
+    top: 226.7;
+    module: 1.524;
+    floors: readonly [14, 11, 11, 8];
+}>;
+export declare const blueCrossFloors: number[];
+export declare function createBlueCrossGeographicBuilding(record: GeoBuilding, projectPlan: (coordinates: [number, number][]) => Plan, offset: [number, number]): BuildingModel;

package/lib/models/blue-cross-geographic.js

@@ -0,0 +1,248 @@
+import * as THREE from "../vendor/three-r186.js";
+import { createBuilder, inside, polygonOf } from "./building-kit.js";
+import { chainSkin, chainsOf, orient, paintedSlab, planOf } from "./facade-grid.js";
+import { createWindowIllumination } from "./window-illumination.js";
+// The Blue Cross and Blue Shield Tower, 300 East Randolph Street (Lohan Associates, 1997;
+// Goettsch Partners' 24-storey addition, 2010): the geographic layout's model, on the
+// mapped outline 95486960 and its parts 284779637 and 284779635. The original layout
+// has no model of it; the drawing shows it right of Aon, outside the excerpt it is fitted
+// to.
+//
+// A glass curtain wall on the 5 ft module wraps a central block, the mapped 227 m part,
+// which stands forward of two end bays, the rest of the mapped 212 m part. Three bands of
+// mechanical floors cross the block, their columns lit blue at night; at the middle band,
+// the top of the 1997 tower, the end bays are open through. A screen carrying the company's
+// emblems rises from the block's roof to the published 226.7 m. Heights are measured on
+// the photograph down from that top; see docs/blue-cross-reference.md. Units are meters;
+// +x is east, +z is south.
+export const blueCrossLevels = Object.freeze({
+    lobbyTop: 10.26, // fourteen floors under the lower band; estimate
+    bands: [[65.7, 72.1], [117.1, 128.1], [170.1, 176.6]], // mechanical floors
+    occupied: 208.3, // the highest occupied floor, published
+    roof: 212.8, // the central block's glass top
+    wings: 212, // the end bays' roof, mapped
+    top: 226.7, // the screen's top, the published architectural height
+    module: 1.524, // 5 ft
+    // Office floors between the bands, each run divided evenly: the lobby to the lower band,
+    // then between the bands, and from the upper band to the top occupied floor.
+    floors: [14, 11, 11, 8],
+});
+const h = blueCrossLevels;
+// Every office floor's level, from the lobby's top to the top occupied floor.
+const zones = [
+    [h.lobbyTop, h.bands[0][0], h.floors[0]], [h.bands[0][1], h.bands[1][0], h.floors[1]],
+    [h.bands[1][1], h.bands[2][0], h.floors[2]], [h.bands[2][1], h.occupied, h.floors[3]],
+];
+// Center five-floor words in the three upper office zones, ordered from the top.
+const messageTopFloors = zones.map(([, , count], zone) => h.floors.slice(0, zone).reduce((sum, floors) => sum + floors, 0)
+    + Math.floor((count + 5) / 2) - 1).reverse().slice(0, 3);
+export const blueCrossFloors = [...zones.flatMap(([from, to, count]) => Array.from({ length: count }, (_, i) => from + (to - from) * i / count)), h.occupied];
+const spandrelBelow = 0.3, spandrelAbove = 0.9;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = [0x414141, 0x464646, 0x3c3c3c, 0x4a4a4a].map(color);
+const litGlass = color(0x8a8a8a), dimGlass = color(0x5c5c5c);
+const spandrel = color(0x383838), recess = color(0x2a2a2a), screen = color(0x3e3e3e), lobby = color(0x333333), roofing = color(0x3a3a3a);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 13, 0x9e3779b1) ^ Math.imul(bay + 37, 0x85ebca77) ^ Math.imul(wall + 23, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 4)
+        return litGlass;
+    if (value < 8)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+const rows = [];
+{
+    const push = (lo, hi, kind, floor) => { if (hi - lo > 1e-6)
+        rows.push({ lo, hi, kind, floor }); };
+    let floor = 0;
+    zones.forEach(([from, to, count], zone) => {
+        for (let i = 0; i < count; i += 1, floor += 1) {
+            const level = from + (to - from) * i / count, next = from + (to - from) * (i + 1) / count;
+            push(rows.at(-1)?.hi ?? level, level + spandrelAbove, "spandrel", floor);
+            push(level + spandrelAbove, next - spandrelBelow, "glass", floor);
+        }
+        const band = h.bands[zone];
+        if (band)
+            push(rows.at(-1).hi, band[1], "band", -1);
+    });
+    // The top occupied floor, under a parapet that rises past the end bays' roof to the
+    // block's, and the screen above.
+    push(rows.at(-1).hi, h.occupied + spandrelAbove, "spandrel", floor);
+    push(h.occupied + spandrelAbove, h.wings - spandrelBelow, "glass", floor);
+    push(h.wings - spandrelBelow, h.wings, "spandrel", -1);
+    push(h.wings, h.roof, "spandrel", -1);
+    push(h.roof, h.top, "screen", -1);
+}
+const rowsBetween = (lo, hi) => rows.filter((row) => row.lo >= lo - 1e-6 && row.hi <= hi + 1e-6);
+export function createBlueCrossGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Blue Cross · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Blue Cross · glass, spandrels and bands", kit.material(0xffffff, { vertexColors: true }));
+    const mullions = kit.batch("Blue Cross · mullions", kit.material(0x2c2c2c));
+    const bars = kit.batch("Blue Cross · band columns and emblems", kit.material(0xb4b4b4));
+    const windows = [];
+    let windowColumns = 0;
+    const outline = (way) => orient(polygonOf(projectPlan(record.parts.find((part) => part.way === way).coordinates)));
+    const footprint = orient(polygonOf(projectPlan(record.footprint.coordinates)));
+    const block = outline(284779637), slab = outline(284779635);
+    // The end bays: the mapped 212 m part less the central block. The two parts share the
+    // corners where the block meets each bay, so the slab's outline splits at those corners
+    // into stretches inside the block and stretches outside it. Each outside stretch is a
+    // bay's outer wall, closed along the block's wall, whose vertices between the same two
+    // corners lie inside the slab.
+    const near = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]) < 0.01;
+    const corners = slab.flatMap((p, i) => (block.some((q) => near(p, q)) ? [i] : []));
+    const bays = corners.flatMap((a, k) => {
+        const b = corners[(k + 1) % corners.length], path = [];
+        for (let i = a;; i = (i + 1) % slab.length) {
+            path.push(slab[i]);
+            if (i === b)
+                break;
+        }
+        const [p, q] = [path[0], path[1]];
+        if (inside(block, [(p[0] + q[0]) / 2, (p[1] + q[1]) / 2]))
+            return [];
+        const [from, to] = [block.findIndex((v) => near(v, path.at(-1))), block.findIndex((v) => near(v, path[0]))];
+        const walk = (step) => { const way = []; for (let j = (from + step + block.length) % block.length; j !== to; j = (j + step + block.length) % block.length)
+            way.push(block[j]); return way; };
+        const back = [walk(1), walk(-1)].find((way) => way.every((v) => inside(slab, v)));
+        return [orient([...path, ...back])];
+    });
+    // A solid on an outline between two heights, its walls the shell's dark core.
+    const solid = (corners, lo, hi, paint) => {
+        planOf(corners).forEach((run) => {
+            const a = run.at(0), b = run.at(run.length), n = run.normal(0);
+            kit.quad(shell, [[a[0], lo, a[1]], [b[0], lo, b[1]], [b[0], hi, b[1]], [a[0], hi, a[1]]], [[n[0], 0, n[1]]], paint);
+        });
+        paintedSlab(kit, shell, corners, lo, false, roofing);
+        paintedSlab(kit, shell, corners, hi, true, roofing);
+    };
+    // The lobby fills the mapped outline to the first office floor.
+    solid(footprint, 0, h.lobbyTop, lobby);
+    solid(block, h.lobbyTop, h.top, spandrel);
+    const middle = h.bands[1];
+    for (const bay of bays) {
+        solid(bay, h.lobbyTop, middle[0], spandrel);
+        solid(bay, middle[1], h.wings, spandrel);
+    }
+    // A wall's skin between two heights, on the runs `keep` accepts: cells two modules wide on
+    // every row, and mullions one module apart on the office floors. Each unbroken stretch of
+    // kept runs along a chain is one box, held 2 cm clear of its ends.
+    const skin = (corners, lo, hi, seed, keep, lift = 0) => {
+        const plan = planOf(corners), cuts = rowsBetween(lo, hi);
+        const heights = [cuts[0].lo + lift, ...cuts.map((row) => row.hi)];
+        const top = Math.min(hi, h.roof) - 0.05;
+        chainsOf(plan).forEach((chain, index) => {
+            const count = Math.max(1, Math.round(chain.length / h.module));
+            const stations = Array.from({ length: count + 1 }, (_, i) => chain.length * i / count);
+            const messageFace = seed === 0 && plan[chain.runs[0]].normal(0)[1] > 0.9 && chain.length > 50;
+            if (messageFace)
+                windowColumns = count;
+            const kept = chain.runs.map((run) => keep(plan[run]));
+            for (let k0 = kept.indexOf(true); k0 >= 0;) {
+                let k1 = k0;
+                while (kept[k1 + 1])
+                    k1 += 1;
+                const s0 = chain.starts[k0] + 0.02, s1 = chain.starts[k1] + plan[chain.runs[k1]].length - 0.02;
+                chainSkin(kit, wall, plan, chain, k0, k1, s0, s1, stations.filter((_, i) => messageFace || i % 2 === 0), heights, 0.02, 0.07, (cell, r) => {
+                    const row = cuts[r];
+                    if (row.kind === "glass") {
+                        if (messageFace)
+                            windows.push({ vertex: wall.positions.length / 3, column: cell - 1, floor: row.floor });
+                        // Subdivide the message face at every mullion while retaining its
+                        // original paired-pane colors when the lights are off.
+                        return paneColor(row.floor, messageFace ? Math.ceil(cell / 2) : cell, seed * 8 + index);
+                    }
+                    if (row.kind === "band")
+                        return recess;
+                    if (row.kind === "screen")
+                        return screen;
+                    return spandrel;
+                }, spandrel);
+                // Mullions on each office run, whole on one run and held clear of its ends. Their
+                // backs stand a centimetre off the wall: on the block's side walls the middle band's
+                // mullions start just inside the end bays, whose closing walls lie in that plane and
+                // face the way the backs do.
+                for (const s of stations) {
+                    const k = chain.starts.findIndex((from, i) => s < from + plan[chain.runs[i]].length + 1e-9);
+                    if (k < k0 || k > k1)
+                        continue;
+                    const run = plan[chain.runs[k]], along = Math.min(Math.max(s - chain.starts[k], 0.3), run.length - 0.3);
+                    if (run.length > 0.6 && top - lo > 1)
+                        kit.box(mullions, run.at(along), run.normal(0), 0.05, 0.01, 0.16, heights[0] + 0.05, top);
+                }
+                k0 = kept.indexOf(true, k1 + 1);
+            }
+        });
+    };
+    // Whether a run lies along an outline's edges, and whether an end bay stands against it.
+    const lies = (run, on) => [0, run.length / 2, run.length].every((s) => {
+        const p = run.at(s);
+        return on.some((q, i) => {
+            const r = on[(i + 1) % on.length], [dx, dz] = [r[0] - q[0], r[1] - q[1]], l = Math.hypot(dx, dz);
+            const t = Math.max(0, Math.min(1, ((p[0] - q[0]) * dx + (p[1] - q[1]) * dz) / (l * l)));
+            return Math.hypot(q[0] + dx * t - p[0], q[1] + dz * t - p[1]) < 0.05;
+        });
+    });
+    const covered = (run) => bays.some((bay) => inside(bay, run.at(run.length / 2, 0.5)));
+    // The end bays cover the block's side walls except through the middle band and above
+    // their roof, so its skin there keeps to those heights. The bays' own skins leave off the
+    // runs they share with the block. `lift` raises the block's foot off the lobby's roof:
+    // where the block meets a bay their skins cross, and their feet would share that plane.
+    skin(block, h.lobbyTop, h.top, 0, (run) => !covered(run), 0.05);
+    skin(block, middle[0] - spandrelBelow, middle[1], 0, covered);
+    skin(block, h.wings, h.top, 0, covered);
+    bays.forEach((bay, i) => {
+        skin(bay, h.lobbyTop, middle[0], i + 1, (run) => !lies(run, block));
+        skin(bay, middle[1], h.wings, i + 1, (run) => !lies(run, block));
+    });
+    // An emblem: a plate standing 7 to 30 cm off the screen, cut to an outline given across and
+    // up from its centre. Its faces fan from the centre, which sees the whole outline, and its
+    // sides follow the outline's edges.
+    const emblem = (centre, t, n, y, shape) => {
+        const point = ([u, v], depth) => [centre[0] + t[0] * u + n[0] * depth, y + v, centre[1] + t[1] * u + n[1] * depth];
+        const out = [n[0], 0, n[1]], back = [-n[0], 0, -n[1]];
+        shape.forEach((p, i) => {
+            const q = shape[(i + 1) % shape.length];
+            kit.triangle(bars, [point([0, 0], 0.3), point(p, 0.3), point(q, 0.3)], [out, out, out]);
+            kit.triangle(bars, [point([0, 0], 0.07), point(q, 0.07), point(p, 0.07)], [back, back, back]);
+            // The edge's side faces away from the centre.
+            const sign = Math.sign((q[1] - p[1]) * (p[0] + q[0]) - (q[0] - p[0]) * (p[1] + q[1])), length = Math.hypot(q[0] - p[0], q[1] - p[1]);
+            const [across, up] = [sign * (q[1] - p[1]) / length, -sign * (q[0] - p[0]) / length];
+            kit.quad(bars, [point(p, 0.07), point(q, 0.07), point(q, 0.3), point(p, 0.3)], [[t[0] * across, up, t[1] * across]]);
+        });
+    };
+    // The company's emblems, 4.2 m tall: a cross, its arms a third of its span, and a shield,
+    // square-shouldered and drawn to a point.
+    const cross = [[0.7, 2.1], [0.7, 0.7], [2.1, 0.7], [2.1, -0.7], [0.7, -0.7], [0.7, -2.1],
+        [-0.7, -2.1], [-0.7, -0.7], [-2.1, -0.7], [-2.1, 0.7], [-0.7, 0.7], [-0.7, 2.1]];
+    const shield = [[-1.8, 2.1], [1.8, 2.1], [1.8, 0.3], [1.6, -0.7], [1.0, -1.5], [0, -2.1], [-1.0, -1.5], [-1.6, -0.7], [-1.8, 0.3]];
+    // The block's columns, exposed in each band and in the screen on its long faces: eight
+    // across each, one to a structural bay. The emblems stand in the screen's first two
+    // bays at the south face's west end, the cross west of the shield.
+    const faces = chainsOf(planOf(block)).filter(({ length }) => length > 50);
+    faces.forEach((chain) => {
+        const plan = planOf(block), run = plan[chain.runs[0]], last = plan[chain.runs.at(-1)];
+        const a = run.at(0), b = last.at(last.length), n = run.normal(0), length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        const t = [(b[0] - a[0]) / length, (b[1] - a[1]) / length];
+        const at = (s) => [a[0] + t[0] * s, a[1] + t[1] * s];
+        const pitch = length / 8;
+        for (let i = 0; i < 8; i += 1) {
+            for (const [lo, hi] of [...h.bands, [h.roof + 0.4, h.top - 0.3]])
+                kit.box(bars, at((i + 0.5) * pitch), n, 0.45, 0.07, 0.4, lo + 0.1, hi - 0.1);
+        }
+        // The south face runs west to east; the emblems stand in its first two bays.
+        if (n[1] > 0.9)
+            [cross, shield].forEach((shape, i) => emblem(at((i + 1) * pitch), t, n, h.roof + 6.7, shape));
+    });
+    const model = kit.finish({ height: h.top, outlines: [shell, mullions], opacity: 0.16 });
+    const glass = model.building.getObjectByName(wall.name);
+    if (!(glass instanceof THREE.Mesh) || !(glass.material instanceof THREE.MeshToonMaterial))
+        throw new Error("Blue Cross window lighting requires its glass mesh and toon material");
+    model.illumination = createWindowIllumination(glass.geometry, glass.material, windows, windowColumns, messageTopFloors);
+    model.building.position.set(offset[0], 0, offset[1]);
+    model.building.userData["geography"] = record;
+    model.building.userData["geographicDetail"] = { levels: h, source: "docs/blue-cross-reference.md" };
+    return model;
+}

package/lib/models/borg-warner-geographic.d.ts

@@ -0,0 +1,20 @@
+import type { BuildingModel, Plan } from "./building-kit.js";
+import type { GeoBuilding } from "./skyline-geography-data.js";
+export declare const borgWarnerLevels: Readonly<{
+    neighbour: 31.1;
+    fascia: number;
+    roof: 73.2;
+    penthouse: 78.6;
+    top: 83.5;
+}>;
+export declare const borgWarnerPalette: Readonly<{
+    glass: number[];
+    lit: 8026746;
+    dim: 4868682;
+    spandrel: 2960685;
+    mullion: 6184542;
+    corner: 5395026;
+    cap: 6974058;
+    plain: 5789784;
+}>;
+export declare function createBorgWarnerGeographicBuilding(record: GeoBuilding, projectPlan: (coordinates: [number, number][]) => Plan, offset: [number, number]): BuildingModel;

package/lib/models/borg-warner-geographic.js

@@ -0,0 +1,143 @@
+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 Borg-Warner Building, 200 South Michigan Avenue (A. Epstein & Sons with William
+// Lescaze, 1958): the geographic layout's model, on the mapped outline 124873918. The
+// original layout has no model of it; the drawing shows it across Adams from Peoples Gas.
+//
+// A curtain wall of aluminium mullions and dark spandrels wraps the Michigan, Adams and
+// south fronts between clad corner columns, under a deep fascia. On the roof, an office
+// penthouse stands flush with the Michigan and south fronts, and a taller block behind it.
+// The roof and the penthouse are the City's 240 and 258 ft, and the block the Skyscraper
+// Center's 83.5 m: each is the published height nearest its drawn reading. The drawn
+// front's top reads 76 m, so heights read on the drawing are scaled to meet the roof; see
+// docs/borg-warner-reference.md. Units are meters; +x is east, +z is south.
+const drawn = (height) => height * 73.2 / 76;
+export const borgWarnerLevels = Object.freeze({
+    neighbour: 31.1, // Symphony Center's roof, the City's 102 ft, over the south front's plain wall
+    fascia: drawn(72.9), // the fascia over the top floor's windows
+    roof: 73.2, // the roof, the City's 240 ft
+    penthouse: 78.6, // the office penthouse's top, the City's 258 ft
+    top: 83.5, // the block behind it, the Skyscraper Center's height
+});
+const h = borgWarnerLevels;
+// The skins' colours: the window tones, and the spandrels, mullions, corner columns, the
+// penthouse's cap and the plain walls, which no window shares.
+export const borgWarnerPalette = Object.freeze({ glass: [0x3a3a3a, 0x3e3e3e, 0x424242, 0x464646], lit: 0x7a7a7a, dim: 0x4a4a4a, spandrel: 0x2d2d2d, mullion: 0x5e5e5e, corner: 0x525252, cap: 0x6a6a6a, plain: 0x585858 });
+const palette = borgWarnerPalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim);
+const spandrel = color(palette.spandrel), mullion = color(palette.mullion), cornerColumn = color(palette.corner), cap = color(palette.cap), plain = color(palette.plain);
+const core = color(0x262626), roofing = color(0x3c3c3c);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 67, 0x9e3779b1) ^ Math.imul(bay + 97, 0x85ebca77) ^ Math.imul(wall + 79, 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(0.5), kind: "curb", floor: 1 }];
+const push = (hi, kind, floor) => rows.push({ lo: rows.at(-1).hi, hi, kind, floor });
+const spandrelTop = (k) => 70.6 - k * 3.21;
+push(drawn(spandrelTop(20) - 0.98), "glass", 1);
+for (let k = 20; k >= 0; k -= 1) {
+    push(drawn(spandrelTop(k)), "spandrel", 22 - k);
+    push(k > 0 ? drawn(spandrelTop(k - 1) - 0.98) : h.fascia, "glass", 22 - k);
+}
+push(h.roof, "fascia", 22);
+// The row that Symphony Center's roof crosses, split there.
+const crossed = rows.findIndex((row) => row.lo < h.neighbour && row.hi > h.neighbour);
+rows.splice(crossed, 1, { ...rows[crossed], hi: h.neighbour }, { ...rows[crossed], lo: h.neighbour });
+// The penthouse's rows: a curb, its windows, and a light cap, as drawn over the fascia.
+const penthouseRows = [
+    { lo: h.roof, hi: h.roof + 0.3, kind: "curb", floor: 23 },
+    { lo: h.roof + 0.3, hi: h.penthouse - 0.6, kind: "glass", floor: 23 },
+    { lo: h.penthouse - 0.6, hi: h.penthouse, kind: "fascia", floor: 23 },
+];
+export function createBorgWarnerGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Borg-Warner Building · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Borg-Warner Building · curtain wall", kit.material(0xffffff, { vertexColors: true }));
+    const block = kit.batch("Borg-Warner Building · rooftop block", kit.material(0x565656));
+    const roofTop = kit.batch("Borg-Warner Building · penthouse", kit.material(0x3c3c3c));
+    const lot = orient(polygonOf(projectPlan(record.footprint.coordinates)));
+    // The lot's south-east corner, with its south wall running west along Symphony Center
+    // and its Michigan front north to Adams.
+    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];
+    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.roof, b[1]], [a[0], h.roof, a[1]]], [[n[0], 0, n[1]]], core);
+    });
+    paintedSlab(kit, shell, lot, 0, false, roofing);
+    paintedSlab(kit, shell, lot, h.roof, true, roofing);
+    // On the roof: the office penthouse, 39 m along the south front and 22 m up Michigan, as
+    // the drawn penthouse meets the projected fronts. It stands 5 cm inside the south front
+    // and 12 cm inside the line between Michigan's corners, which the mapped wall stands up to
+    // 9.5 cm inside. Behind it, the taller block stands 14 to 27.4 m from Michigan and 1 to
+    // 28.3 m from the south front, as its drawn corners project, sunk 10 cm into the roof so
+    // that its floor lies clear of the penthouse's. Both footprints are estimates.
+    const penthouse = rect(0.12, 39, 0.05, 22);
+    kit.prism(roofTop, planOf(penthouse), [h.roof, h.penthouse]);
+    kit.prism(block, planOf(rect(14, 27.4, 1, 28.3)), [h.roof - 0.1, h.top]);
+    const paints = { spandrel, mullion, corner: cornerColumn, cap, plain };
+    const skin = (plan, keep, span, seed, openings) => {
+        const heights = [span[0].lo, ...span.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);
+            chainSkin(kit, wall, plan, chain, 0, chain.runs.length - 1, s0, s1, columns, heights, 0.02, 0.07, (bay, r) => {
+                const row = span[r], shows = cell((columns[bay - 1] + columns[bay]) / 2, row);
+                return shows === "glass" ? paneColor(row.floor, bay, seed * 8 + index) : paints[shows];
+            }, plain);
+        });
+    };
+    const near = (list, x) => Math.min(...list.map((c) => Math.abs(x - c)));
+    // The curtain wall: corner columns 1.2 m wide at each end, and mullions 12 cm wide about
+    // 1.33 m apart between them, as drawn: 22 bays on Michigan. Below `plainUnder` the wall
+    // is a neighbour's, plain.
+    const curtain = (plainUnder = 0) => (length) => {
+        const count = Math.max(1, Math.round((length - 2.4) / 1.33)), pitch = (length - 2.4) / count;
+        const mullions = Array.from({ length: count - 1 }, (_, k) => 1.2 + (k + 1) * pitch);
+        const cuts = [1.2, length - 1.2, ...mullions.flatMap((m) => [m - 0.06, m + 0.06])];
+        return [[0, ...cuts.sort((p, q) => p - q), length], (mid, row) => {
+                if (row.hi <= plainUnder + 1e-6)
+                    return "plain";
+                if (mid < 1.2 || mid > length - 1.2)
+                    return "corner";
+                if (near(mullions, mid) < 0.06)
+                    return "mullion";
+                return row.kind === "glass" ? "glass" : row.kind === "fascia" ? (row.floor === 23 ? "cap" : "spandrel") : "spandrel";
+            }];
+    };
+    // The alley's windows, which the drawing does not show: 1.6 m wide, spread evenly about
+    // 3.2 m apart, one to each floor above the lobby.
+    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], (mid, row) => (row.kind === "glass" && row.floor > 1 && near(centres, mid) < 0.8 ? "glass" : "plain")];
+    };
+    const facing = (x, z) => (run) => run.normal(0)[0] * x + run.normal(0)[1] * z > 0.9;
+    // Michigan and Adams carry the curtain wall to the roof; the south front above Symphony
+    // Center's 102 ft roof, plain below; the alley has windows.
+    skin(planOf(lot), (run) => facing(1, 0)(run) || facing(0, -1)(run), rows, 0, curtain());
+    skin(planOf(lot), facing(0, 1), rows, 1, curtain(h.neighbour));
+    skin(planOf(lot), facing(-1, 0), rows, 2, alley);
+    // The penthouse's glass between the same mullions, under its cap.
+    skin(planOf(penthouse), () => true, penthouseRows, 3, curtain());
+    const model = kit.finish({ height: h.top, outlines: [shell, roofTop, block], 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/borg-warner-reference.md" };
+    return model;
+}

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

@@ -0,0 +1,10 @@
+import type { BuildingModel, Plan } from "./building-kit.js";
+import type { GeoBuilding } from "./skyline-geography-data.js";
+export declare const buckinghamLevels: Readonly<{
+    lowestFloor: 18.94;
+    pitch: 2.5456;
+    capFoot: 117.4;
+    roof: 119;
+    top: 121.9;
+}>;
+export declare function createBuckinghamGeographicBuilding(record: GeoBuilding, projectPlan: (coordinates: [number, number][]) => Plan, offset: [number, number]): BuildingModel;