@a2f0/skyline 0.0.0-stage → 0.1.2

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

@@ -0,0 +1,121 @@
+import * as THREE from "../vendor/three-r186.js";
+import { createBuilder, polygonOf } from "./building-kit.js";
+import { chainSkin, chainsOf, orient, paintedSlab, planOf, turnAt, turnsAt } from "./facade-grid.js";
+// The Buckingham, 360 East Randolph Street (Fujikawa Johnson & Associates, 1982): the
+// geographic layout's model, on the mapped outline 95486940 and its rooftop part 284790189.
+// The original layout has no model of it; the drawing shows it right of 340 on the Park,
+// outside the excerpt it is fitted to.
+//
+// A concrete frame of five bays a face, a band at every floor over bronze ribbon windows. On
+// the south, east and north faces the end bays stand forward of the middle three, and two
+// corners are notched for stacked balconies. The top floor's tall openings sit under a cap
+// at the mapped 119 m, and the rooftop enclosure rises to the published 121.9 m. Floor levels
+// are measured on the drawing down from the mapped roof; see docs/buckingham-reference.md.
+// Units are meters; +x is east, +z is south.
+export const buckinghamLevels = Object.freeze({
+    lowestFloor: 18.94, // floor 7, the drawing's lowest floor line
+    pitch: 2.5456, // the drawn floor lines, 36 floors apart from floor 7's to floor 43's
+    capFoot: 117.4, // the top floor's openings' head, under the cap
+    roof: 119, // the cap's top, mapped
+    top: 121.9, // the rooftop enclosure's top, the published architectural height
+});
+const h = buckinghamLevels;
+// Each floor's level, from the second, over the lobby, to the 44th.
+const floor = (n) => h.lowestFloor + (n - 7) * h.pitch;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = [0x303030, 0x343434, 0x383838, 0x3c3c3c].map(color);
+const litGlass = color(0x6e6e6e), dimGlass = color(0x464646);
+const concrete = color(0x4c4c4c), lobby = color(0x3a3a3a), core = color(0x262626), roofing = color(0x3a3a3a), enclosure = color(0x2e2e2e);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 19, 0x9e3779b1) ^ Math.imul(bay + 43, 0x85ebca77) ^ Math.imul(wall + 31, 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: floor(2) - 0.3, kind: "lobby", floor: 1 }];
+for (let n = 2; n <= 43; n += 1) {
+    rows.push({ lo: floor(n) - 0.3, hi: floor(n) + 0.55, kind: "band", floor: n });
+    rows.push({ lo: floor(n) + 0.55, hi: floor(n + 1) - 0.3, kind: "glass", floor: n });
+}
+rows.push({ lo: floor(44) - 0.3, hi: floor(44) + 1.4, kind: "band", floor: 44 });
+rows.push({ lo: floor(44) + 1.4, hi: h.capFoot, kind: "glass", floor: 44 });
+rows.push({ lo: h.capFoot, hi: h.roof, kind: "band", floor: 45 });
+const heights = [rows[0].lo, ...rows.map((row) => row.hi)];
+export function createBuckinghamGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Buckingham · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Buckingham · frame and glass", kit.material(0xffffff, { vertexColors: true }));
+    const piers = kit.batch("Buckingham · piers", kit.material(0x565656));
+    const balconies = kit.batch("Buckingham · corner balconies", kit.material(0x5a5a5a));
+    const outline = (way) => orient(polygonOf(projectPlan(record.parts.find((part) => part.way === way).coordinates)));
+    const tower = outline(95486940), roofRoom = outline(284790189);
+    // A solid on an outline between two heights.
+    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);
+    };
+    solid(tower, 0, h.roof, core);
+    solid(roofRoom, h.roof, h.top, enclosure);
+    // Every wall's skin, one box a chain, held 2 cm clear of its ends, or 9 cm, past its own
+    // depth, where the outline turns in and the next wall's skin would otherwise cross it. A
+    // face's cells are a quarter bay wide, with its corner piers painted in its end cells.
+    const plan = planOf(tower), chains = chainsOf(plan);
+    chains.forEach((chain, index) => {
+        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 count = Math.max(1, Math.round((chain.length - 1.2) / 1.6));
+        const columns = chain.length > 4 ? [0, 0.6, ...Array.from({ length: count - 1 }, (_, i) => 0.6 + (chain.length - 1.2) * (i + 1) / count), chain.length - 0.6, chain.length] : [0, chain.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], pier = chain.length > 4 && (bay <= 1 || bay >= columns.length - 1);
+            if (row.kind === "lobby")
+                return lobby;
+            if (row.kind === "band" || pier)
+                return concrete;
+            return paneColor(row.floor, bay, index);
+        }, concrete);
+        // Piers stand proud between a wall's bays, about 6.4 m wide: three across a face's
+        // set-back middle and five across the flat west face; an end bay has none.
+        const bays = Math.round(chain.length / 6.5);
+        for (let k = 1; k < bays; k += 1) {
+            const s = chain.length * k / bays, j = chain.starts.findLastIndex((start) => start <= s), run = plan[chain.runs[j]];
+            kit.box(piers, run.at(s - chain.starts[j]), run.normal(0), 0.3, 0.05, 0.25, 0.3, h.roof - 0.1);
+        }
+    });
+    // The notched corners: two short walls turning in between two faces. A balcony fills each
+    // notch on every floor to the 43rd, a slab held clear of the walls' skins under an L of
+    // railing along its open sides.
+    chains.forEach((chain, i) => {
+        const next = chains[(i + 1) % chains.length];
+        if (chain.length > 3 || next.length > 3 || turnAt(plan[chain.runs.at(-1)], plan[next.runs[0]]) <= 0)
+            return;
+        const a = plan[chain.runs[0]], b = plan[next.runs[0]];
+        const [p0, p1, p2] = [a.at(0), a.at(a.length), b.at(b.length)];
+        const [na, nb] = [a.normal(0), b.normal(0)];
+        const q = [p0[0] + p2[0] - p1[0], p0[1] + p2[1] - p1[1]];
+        const off = (p, n, d) => [p[0] + n[0] * d, p[1] + n[1] * d];
+        const a0 = off(p0, na, 0.07), b0 = off(p2, nb, 0.07), inner = off(off(p1, na, 0.07), nb, 0.07);
+        // Railing: the slab's open sides, 5 cm deep, turned in toward the notch's inner corner.
+        const inward = (from, to) => {
+            const [dx, dz] = [to[0] - from[0], to[1] - from[1]], l = Math.hypot(dx, dz), n = [-dz / l, dx / l];
+            return (inner[0] - from[0]) * n[0] + (inner[1] - from[1]) * n[1] > 0 ? n : [-n[0], -n[1]];
+        };
+        const [na0, nb0] = [inward(a0, q), inward(q, b0)];
+        const rail = [a0, q, b0, off(b0, nb0, 0.05), off(off(q, na0, 0.05), nb0, 0.05), off(a0, na0, 0.05)];
+        for (let n = 2; n <= 43; n += 1) {
+            kit.prism(balconies, planOf(orient([inner, a0, q, b0])), [floor(n) - 0.12, floor(n) + 0.12]);
+            kit.prism(balconies, planOf(orient(rail)), [floor(n) + 0.12, floor(n) + 1.0]);
+        }
+    });
+    const model = kit.finish({ height: h.top, outlines: [shell, piers], 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/buckingham-reference.md" };
+    return model;
+}