@a2f0/skyline 0.0.0-stage → 0.1.2

package/site/models/swissotel-geographic.js

@@ -0,0 +1,79 @@
+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";
+// Swissôtel Chicago, 323 East Wacker Drive (Harry Weese, 1989): the geographic layout's model,
+// on the hotel's mapped tower part 641288601. The original layout has no model of it. From
+// the photograph's camera it stands behind Three Illinois Center and The Buckingham, and fills
+// the seam where their corners meet.
+//
+// A triangular tower of reflective glass: a flush grid of thin mullions about 1.5 m apart and
+// a transom at each floor, a panel to a floor, under a flat roof at the published 139.3 m. The
+// floors divide that height by OpenStreetMap's 45 levels. See docs/swissotel-reference.md.
+// Units are meters; +x is east, +z is south.
+export const swissotelLevels = Object.freeze({
+    levels: 45, // OpenStreetMap's count, a panel to each
+    roof: 139.3, // the published height, the Skyscraper Center's 457 ft
+    module: 1.5, // the mullions' spacing, read on the photographs
+    frame: 0.06, // each mullion's and transom's width
+    coping: 0.1, // the roof's coping over the top panel
+});
+const h = swissotelLevels;
+const pitch = h.roof / h.levels;
+// The skins' colours: the window tones, and the frame, which no window shares.
+export const swissotelPalette = Object.freeze({ glass: [0x2d2d2d, 0x313131, 0x353535, 0x292929], lit: 0x878787, dim: 0x515151, frame: 0x414141 });
+const palette = swissotelPalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim), frame = color(palette.frame);
+const core = color(0x1e1e1e), roofing = color(0x323232);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 71, 0x9e3779b1) ^ Math.imul(bay + 13, 0x85ebca77) ^ Math.imul(wall + 47, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 12)
+        return litGlass;
+    if (value < 18)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+export const swissotelRows = [];
+for (let n = 1; n <= h.levels; n += 1) {
+    const lo = n === 1 ? 0.25 : (n - 1) * pitch + h.frame / 2, hi = n === h.levels ? h.roof - h.coping : n * pitch - h.frame / 2;
+    swissotelRows.push({ lo, hi, kind: "glass", floor: n });
+    swissotelRows.push({ lo: hi, hi: n === h.levels ? h.roof : n * pitch + h.frame / 2, kind: "frame", floor: n });
+}
+const rows = swissotelRows;
+export function createSwissotelGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Swissôtel · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Swissôtel · curtain wall", kit.material(0xffffff, { vertexColors: true }));
+    const lot = orient(polygonOf(projectPlan(record.footprint.coordinates)));
+    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);
+    // Every face's curtain wall, one box to a chain, held 2 cm clear of its ends or 9 cm where
+    // the outline turns in: a mullion on each module, from the chain's middle out, and the
+    // panels between.
+    const plan = planOf(lot), heights = [rows[0].lo, ...rows.map((row) => row.hi)];
+    chainsOf(plan).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.floor(chain.length / 2 / h.module);
+        const lines = Array.from({ length: 2 * count + 1 }, (_, k) => chain.length / 2 + (k - count) * h.module);
+        const cuts = lines.flatMap((c) => [c - h.frame / 2, c + h.frame / 2]).filter((s) => s > s0 + 0.01 && s < s1 - 0.01);
+        const columns = [s0, ...cuts, s1];
+        chainSkin(kit, wall, plan, chain, 0, chain.runs.length - 1, s0, s1, columns, heights, 0.02, 0.06, (bay, r) => {
+            const row = rows[r], middle = (columns[bay - 1] + columns[bay]) / 2;
+            if (row.kind === "frame" || lines.some((c) => Math.abs(middle - c) < h.frame / 2))
+                return frame;
+            return paneColor(row.floor, bay, index);
+        }, frame);
+    });
+    const model = kit.finish({ height: h.roof, 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/swissotel-reference.md" };
+    return model;
+}

package/site/models/three-illinois-center-geographic.js

@@ -0,0 +1,86 @@
+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";
+// Three Illinois Center, 303 East Wacker Drive (Fujikawa Conterato Lohan and Associates,
+// 1979): the geographic layout's model, on the mapped outline 95486958. The original layout
+// has no model of it. From the photograph's camera its east end stands in the gap between
+// 340 on the Park and The Buckingham, where the drawing's `buckingham-west` group paints an
+// office tower of ribbon windows under a plain top.
+//
+// A dark bronze box after One and Two Illinois Center, of 30 storeys: a curtain wall of
+// mullions on a 5 ft module, glass over a spandrel on each floor at the published 11.5 ft
+// slab to slab, over the lobby's glass, and the top two floors' windowless mechanical
+// penthouse, the spandrels' bronze with the mullions carried through, under a flat roof at
+// the published 106.7 m. The penthouse was glazed around 2019; the model keeps it as the
+// 2013 photograph shows it. See docs/three-illinois-center-reference.md. Units are meters;
+// +x is east, +z is south.
+export const threeIllinoisLevels = Object.freeze({
+    pitch: 3.505, // the published 11.5 ft slab to slab
+    lobby: 106.7 - 29 * 3.505, // the lobby's height, what the 29 floors over it leave under the roof
+    fascia: 1.26, // the lobby's fascia, the second floor's spandrel carried down
+    penthouse: 29, // the first of the two mechanical floors
+    roof: 106.7, // the published height, the Skyscraper Center's and Emporis's 350 ft
+    module: 1.524, // the curtain wall's 5 ft module
+});
+const h = threeIllinoisLevels;
+const floor = (n) => (n < 2 ? 0 : h.lobby + (n - 2) * h.pitch);
+// The skins' colours: the window tones, and the mullions and spandrels, which no window
+// shares.
+export const threeIllinoisPalette = Object.freeze({ glass: [0x1b1b1b, 0x1f1f1f, 0x232323, 0x181818], lit: 0x707070, dim: 0x464646, mullion: 0x323232, spandrel: 0x282828 });
+const palette = threeIllinoisPalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim);
+const mullion = color(palette.mullion), spandrel = color(palette.spandrel);
+const core = color(0x171717), roofing = color(0x2b2b2b);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 61, 0x9e3779b1) ^ Math.imul(bay + 29, 0x85ebca77) ^ Math.imul(wall + 83, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 9)
+        return litGlass;
+    if (value < 14)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+export const threeIllinoisRows = [{ lo: 0.25, hi: h.lobby + 0.9 - h.fascia, kind: "glass", floor: 1 }];
+for (let n = 2; n < h.penthouse; n += 1) {
+    threeIllinoisRows.push({ lo: n === 2 ? h.lobby + 0.9 - h.fascia : floor(n), hi: floor(n) + 0.9, kind: "spandrel", floor: n });
+    threeIllinoisRows.push({ lo: floor(n) + 0.9, hi: floor(n + 1), kind: "glass", floor: n });
+}
+threeIllinoisRows.push({ lo: floor(h.penthouse), hi: h.roof, kind: "penthouse", floor: h.penthouse });
+const rows = threeIllinoisRows;
+export function createThreeIllinoisCenterGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Three Illinois Center · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Three Illinois Center · curtain wall", kit.material(0xffffff, { vertexColors: true }));
+    const lot = orient(polygonOf(projectPlan(record.footprint.coordinates)));
+    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);
+    // Every face's curtain wall, one box to a chain, held 2 cm clear of its ends or 9 cm where
+    // the outline turns in: a 10 cm mullion on each 5 ft module, from the chain's middle out,
+    // carried up through the penthouse, with glass or spandrel between.
+    const plan = planOf(lot), heights = [rows[0].lo, ...rows.map((row) => row.hi)];
+    chainsOf(plan).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.floor(chain.length / 2 / h.module);
+        const lines = Array.from({ length: 2 * count + 1 }, (_, k) => chain.length / 2 + (k - count) * h.module);
+        const cuts = lines.flatMap((c) => [c - 0.05, c + 0.05]).filter((s) => s > s0 + 0.01 && s < s1 - 0.01);
+        const columns = [s0, ...cuts, s1];
+        chainSkin(kit, wall, plan, chain, 0, chain.runs.length - 1, s0, s1, columns, heights, 0.02, 0.08, (bay, r) => {
+            const row = rows[r], middle = (columns[bay - 1] + columns[bay]) / 2;
+            if (lines.some((c) => Math.abs(middle - c) < 0.05))
+                return mullion;
+            return row.kind === "glass" ? paneColor(row.floor, bay, index) : spandrel;
+        }, mullion);
+    });
+    const model = kit.finish({ height: h.roof, 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/three-illinois-center-reference.md" };
+    return model;
+}

package/site/models/trump-geographic.js

@@ -0,0 +1,51 @@
+import { polygonOf } from "./building-kit.js";
+import { buildTrumpTower, trumpLevels } from "./trump-tower.js";
+// Trump International Hotel and Tower: the geographic layout's model, on the mapped podium
+// 64594680, tiers 188338549 and 188338550, shaft 188338548 and crown 188338859, and the
+// spire above the crown. The tower is the shared generator in
+// trump-tower.ts, the same one the original layout's copy uses. The setbacks keep the mapped
+// parts' 60, 120 and 200 m; the roof, the shoulder, the crown and the spire's joints are
+// measured on the photograph, down from the published tip, where the map's 345 and 357 m
+// run about ten metres low. The spire stands where the photograph shows it. See
+// docs/trump-reference.md. Units are meters; +x is east, +z is south.
+export const trumpGeographicLevels = Object.freeze({
+    podium: trumpLevels.podium,
+    setbacks: trumpLevels.setbacks,
+    roof: trumpLevels.roof,
+    shoulder: trumpLevels.shoulder,
+    crownTop: trumpLevels.crownTop,
+    joints: trumpLevels.joints,
+    tip: trumpLevels.tip, // published architectural height
+});
+const h = trumpGeographicLevels;
+// The roof steps down north of the mapped shaft's east-face notch.
+export const trumpNotch = [-113.6, -448.4];
+// The spire stands where the photograph shows it on the crown: 4.05 m west of the mapped
+// spire part's centre across the photograph's line of sight, whose depth it cannot show.
+// The drawn crown matches the mapped crown part to three layer units; the mapped spire
+// stands 24 units right of the drawn one. See docs/trump-reference.md.
+export const trumpSpire = [-124.72, -458.66];
+export function createTrumpGeographicBuilding(record, projectPlan, offset) {
+    const outline = (way) => polygonOf(projectPlan(record.parts.find((p) => p.way === way).coordinates));
+    const shaft = outline(188338548);
+    // The mapped vertex at the notch fixes the step's line.
+    const notch = shaft.reduce((best, p) => (Math.hypot(p[0] - trumpNotch[0], p[1] - trumpNotch[1]) < Math.hypot(best[0] - trumpNotch[0], best[1] - trumpNotch[1]) ? p : best));
+    const model = buildTrumpTower({
+        name: record.name,
+        id: record.id,
+        tiers: [
+            { outline: polygonOf(projectPlan(record.footprint.coordinates)), top: h.podium },
+            { outline: outline(188338549), top: h.setbacks[0] },
+            { outline: outline(188338550), top: h.setbacks[1] },
+            { outline: shaft, top: h.roof },
+        ],
+        step: notch[1],
+        crown: outline(188338859),
+        spire: trumpSpire,
+        base: 0,
+    });
+    model.building.position.set(offset[0], 0, offset[1]);
+    model.building.userData["geography"] = record;
+    model.building.userData["geographicDetail"] = { levels: h, source: "docs/trump-reference.md" };
+    return model;
+}

package/site/models/trump-international-tower.js

@@ -0,0 +1,84 @@
+import { geographicBuildings } from "./skyline-geography-data.js";
+import { projectGround } from "./skyline-geography.js";
+import { trumpNotch, trumpSpire } from "./trump-geographic.js";
+import { buildTrumpTower, crownFoot, floorLines, mullionPoints, topOutlines, trumpLevels } from "./trump-tower.js";
+// Trump International Hotel and Tower on its mapped plan, in real meters, for the skyline
+// study's original layout, which places this copy in skyline-study.ts. trump-tower.ts builds
+// it, and the geographic model on the same parts. The tower's rounded and bevelled shaft has
+// no simpler published plan than the map's, so the copy keeps the mapped shaft and crown,
+// shifted to put the shaft's centre at the origin. Its shaft runs straight down to the
+// drawing's datum: the drawing hides everything below One Prudential's roof, and the
+// original layout stands Trump 65 m behind One Prudential and just in front of Two
+// Prudential, where the mapped setbacks would pass through both. See docs/trump-reference.md.
+// Units are meters; +x is east and +z is south.
+const record = geographicBuildings.find((entry) => entry.id === "building-trump-tower-only");
+const mapped = (coordinates) => coordinates.map((corner) => { const [east, north] = projectGround(corner); return [east, -north]; });
+const part = (way) => mapped(record.parts.find((entry) => entry.way === way).coordinates);
+// The shaft's mapped bounds' centre.
+const shaftCorners = part(188338548);
+const origin = [(Math.min(...shaftCorners.map(([x]) => x)) + Math.max(...shaftCorners.map(([x]) => x))) / 2, (Math.min(...shaftCorners.map(([, z]) => z)) + Math.max(...shaftCorners.map(([, z]) => z))) / 2];
+const local = ([x, z]) => [x - origin[0], z - origin[1]];
+const shift = (corners) => corners.map(local);
+const shaft = shift(shaftCorners);
+const notch = shaft.reduce((best, p) => (Math.hypot(p[0] - local(trumpNotch)[0], p[1] - local(trumpNotch)[1]) < Math.hypot(best[0] - local(trumpNotch)[0], best[1] - local(trumpNotch)[1]) ? p : best));
+const crown = shift(part(188338859));
+const spire = local(trumpSpire);
+// The skyline drawing shows the tower above One Prudential, and its platform datum crosses
+// the tower above the street: fitted with the placement in skyline-study.ts, which scales,
+// turns, and places this copy. Its y = 0 is that datum.
+export const trumpSkylineBase = 40.7;
+export function createTrumpInternationalTowerBuilding() {
+    return buildTrumpTower({
+        name: "Trump International Hotel and Tower",
+        id: "building-trump-tower-only",
+        tiers: [{ outline: shaft, top: trumpLevels.roof }],
+        step: notch[1],
+        crown,
+        spire,
+        base: trumpSkylineBase,
+    });
+}
+// Features the skyline test projects against the drawing, in this copy's coordinates.
+const h = trumpLevels;
+const at = ([x, z], real) => [x, real - trumpSkylineBase, z];
+const vertex = (corners, near) => corners.reduce((best, p) => (Math.hypot(p[0] - near[0], p[1] - near[1]) < Math.hypot(best[0] - near[0], best[1] - near[1]) ? p : best));
+// Points along the bevelled south-east face, from its south corner.
+const bevel = [vertex(shaft, local([-130.2, -417.4])), vertex(shaft, local([-114.5, -432.7]))];
+// The bevel faces south-east, so outward is to the left walking from its south corner.
+const alongBevel = (s, depth) => {
+    const [a, b] = bevel, l = Math.hypot(b[0] - a[0], b[1] - a[1]), t = [(b[0] - a[0]) / l, (b[1] - a[1]) / l];
+    return [a[0] + t[0] * s - t[1] * depth, a[1] + t[1] * s + t[0] * depth];
+};
+// Every mullion of the shaft and of the crown, in plan, the same placement the model uses.
+const tops = topOutlines(shaft, notch[1], crown);
+const shaftMullions = mullionPoints(tops.shaft, () => 0), crownMullions = mullionPoints(tops.crown, crownFoot(tops.cap));
+// A mullion's point halfway out to its face, at a height.
+const mullion = (list, index, real) => { const { at: [x, z], normal: [nx, nz] } = list[index]; return at([x + nx * 0.115, z + nz * 0.115], real); };
+export const trumpFeatures = {
+    // The roof's south-west corner and its east end at the bevel, where the drawn roof turns.
+    trumpTowerWestRoof: at(vertex(shaft, local([-146.1, -422.9])), h.roof),
+    trumpTowerEastStart: at(vertex(shaft, local([-111.7, -435.3])), h.roof),
+    // The step: the notch's corner at the roof and at the shoulder, and the shoulder's far end.
+    trumpRoofStepTop: at(notch, h.roof),
+    trumpRoofStepBottom: at(notch, h.shoulder),
+    trumpEastShoulder: at(vertex(shaft, local([-115.6, -464.9])), h.shoulder),
+    trumpCrownWest: at(vertex(crown, local([-133.4, -443.3])), h.crownTop),
+    trumpCrownEast: at(vertex(crown, local([-116.4, -463.7])), h.crownTop),
+    trumpSpireTip: at(spire, h.tip),
+    trumpSpireUpperJoint: at(spire, h.joints[1]),
+    trumpSpireLowerJoint: at(spire, h.joints[0]),
+    // A window on the short south face, above One Prudential and well left of its mast, for hover.
+    trumpFacadeProbe: at(local([-135.75, -416.3 + 0.07]), floorLines[90] + 1.6),
+    // Behind One Prudential in the drawing.
+    trumpBehindPrudential: at(alongBevel(10, 0.07), floorLines[30] + 1.6),
+    // The drawn floor rows: spandrel centres 2 m along the bevel, on the drawing's sampled rows.
+    trumpFloorBands: [0, 7, 14, 21, 28, 35, 40].map((row) => at(alongBevel(2, 0.07), h.floorLine + row * h.pitch + 0.1)),
+    // The drawing's mullion lines, each checked against the model's nearest mullion, counted
+    // round the shaft's walls and the crown's from the chain each starts. The drawing spaces
+    // its lines unevenly: it doubles some where the mullions bunch round a curve, and skips
+    // most of the east face's. The shaft's lines were measured 289 m up, the crown's at its top.
+    trumpFrontMullions: [19, 20, 21, 22, 23, 24, 24, 25, 26, 27, 28, 29, 30, 31, 32, 34].map((i) => mullion(shaftMullions, i, 289)),
+    trumpCornerMullions: [35, 37, 38].map((i) => mullion(shaftMullions, i, 289)),
+    trumpEastMullions: [41, 43, 45, 46, 52, 53, 54, 56, 57, 59].map((i) => mullion(shaftMullions, i, 289)),
+    trumpCrownMullions: [26, 27, 27, 28, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 36, 37, 38, 39, 40, 0, 1, 2, 3].map((i) => mullion(crownMullions, i, 364.5)),
+};

package/site/models/trump-tower.js

@@ -0,0 +1,229 @@
+import * as THREE from "../vendor/three-r186.js";
+import { createBuilder, inside } from "./building-kit.js";
+import { chainSkin, chainsOf, jointTrim, orient, planOf, turnsAt } from "./facade-grid.js";
+// Heights above the street. The tip is published; the setbacks are the mapped parts'; the
+// roof, the shoulder, the crown, the spire's joints, and the floor rows are measured on the
+// photograph the drawing was traced from, down from the tip. See docs/trump-reference.md.
+export const trumpLevels = Object.freeze({
+    podium: 60,
+    setbacks: [120, 200],
+    roof: 354.4,
+    shoulder: 347.3,
+    crownTop: 364.9,
+    joints: [377.4, 402.2],
+    tip: 423.2,
+    // Floor lines: one on the drawn rows, then every 3.214 m, from a tall ground storey up.
+    floorLine: 187.01,
+    pitch: 3.214,
+    lobbyTop: 10.5,
+    // The curtain wall's 6 ft units.
+    module: 1.8288,
+});
+const h = trumpLevels;
+// Every floor line from the lobby's top to the crown's top: the crown's mechanical floors
+// keep the tower's pitch.
+export const floorLines = (() => {
+    const lines = [];
+    let first = h.floorLine;
+    while (first - h.pitch >= h.lobbyTop - 1e-6)
+        first -= h.pitch;
+    for (let level = first; level < h.crownTop; level += h.pitch)
+        lines.push(level);
+    return lines;
+})();
+// Each floor's brushed stainless spandrel straddles its slab; the glass fills the rest.
+const spandrelBelow = 0.35, spandrelAbove = 0.55;
+// Mullions stand one module apart along each wall, a curved run of the trace following on
+// from the last, so they keep their rhythm round the rounded corners. A turn of 40° or more
+// starts a new wall: the bevels and the notches.
+const bend = 40 * Math.PI / 180;
+export function mullionStations(length) {
+    const count = Math.max(1, Math.round(length / h.module));
+    return Array.from({ length: count + 1 }, (_, i) => length * i / count);
+}
+const mullionHalf = 0.06, mullionDepth = 0.23;
+// How far a wall's glass and mullions stop short of a stretch something else stands on.
+const clearance = 0.2;
+// Where a chain's mullions stand: one per station, whole on one run, nudged clear of the
+// joints and held back from the wall's ends by its own depth, so it meets neither a
+// neighbouring wall's mullion nor the end of a run's glass. Each is its run's index in the
+// chain and the distance along that run.
+function mullionsOn(plan, chain, froms) {
+    const placed = [];
+    for (const station of mullionStations(chain.length)) {
+        const k = chain.starts.findIndex((start, i) => station < start + plan[chain.runs[i]].length + 1e-9);
+        if (k < 0)
+            continue;
+        const run = plan[chain.runs[k]], start = chain.starts[k];
+        const clear = (other) => (other < 0 || other >= chain.runs.length ? mullionDepth + 0.02 : froms[other] > froms[k] ? clearance : 0.03) + mullionHalf;
+        const lo = clear(k - 1), hi = run.length - clear(k + 1);
+        if (hi >= lo)
+            placed.push({ k, s: Math.min(Math.max(station - start, lo), hi) });
+    }
+    return placed;
+}
+// Every mullion of an outline's curtain wall, in plan, with the wall's outward normal, for
+// features: the same placement the model is built with, given what each run stands on.
+export function mullionPoints(corners, runFrom) {
+    const plan = planOf(orient(corners));
+    return chainsOf(plan, bend).flatMap((chain) => {
+        const froms = chain.runs.map((index) => runFrom(plan[index]));
+        return mullionsOn(plan, chain, froms).map(({ k, s }) => { const run = plan[chain.runs[k]]; return { at: run.at(s), normal: run.normal(0) }; });
+    });
+}
+const color = (hex) => new THREE.Color(hex);
+const glassTones = [0x2a2a2a, 0x2e2e2e, 0x333333, 0x272727].map(color);
+const litGlass = color(0x7c7c7c), dimGlass = color(0x505050);
+const spandrel = color(0x474747), crownGlass = color(0x232323), crownBand = color(0x3c3c3c);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 11, 0x9e3779b1) ^ Math.imul(bay + 29, 0x85ebca77) ^ Math.imul(wall + 3, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 3)
+        return litGlass;
+    if (value < 6)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+// An outline with the crossings of a line of constant z inserted as vertices, and the part
+// of it south of that line.
+export function splitAt(corners, z) {
+    const outline = [], south = [];
+    corners.forEach((a, i) => {
+        const b = corners[(i + 1) % corners.length];
+        outline.push(a);
+        if (a[1] >= z - 1e-9)
+            south.push(a);
+        if ((a[1] - z) * (b[1] - z) < -1e-12) {
+            const t = (z - a[1]) / (b[1] - a[1]), cross = [a[0] + (b[0] - a[0]) * t, z];
+            outline.push(cross);
+            south.push(cross);
+        }
+    });
+    return { outline, south };
+}
+// The shaft's outline broken at the step's line; the cap, its part south of the line, which
+// stands on to the roof; and the crown's outline broken there too. The crown crosses the
+// step's line, and its crossings break the step's wall, so the stretch the crown stands on
+// carries no facade.
+export function topOutlines(shaftCorners, step, crownCorners) {
+    const split = splitAt(orient(shaftCorners), step);
+    const crown = splitAt(orient(crownCorners), step).outline;
+    const crossings = crown.filter(([, z]) => Math.abs(z - step) < 1e-9);
+    const cap = orient(split.south).flatMap((corner, i, corners) => {
+        const next = corners[(i + 1) % corners.length];
+        if (Math.abs(corner[1] - step) > 1e-9 || Math.abs(next[1] - step) > 1e-9)
+            return [corner];
+        const between = crossings.filter(([x]) => (x - corner[0]) * (x - next[0]) < -1e-9).sort((a, b) => Math.abs(a[0] - corner[0]) - Math.abs(b[0] - corner[0]));
+        return [corner, ...between];
+    });
+    return { shaft: split.outline, cap, crown };
+}
+// What a crown wall stands on: the roof where it rises from the cap, the shoulder elsewhere.
+export const crownFoot = (cap) => (run) => (inside(cap, run.at(run.length / 2, 0.3)) ? h.roof : h.shoulder);
+export function buildTrumpTower(form) {
+    const kit = createBuilder(form.name, form.id);
+    const shell = kit.batch("Trump · tower shell", kit.material(0x2c2c2c));
+    const glazing = kit.batch("Trump · glass and spandrels", kit.material(0xffffff, { vertexColors: true }));
+    const mullions = kit.batch("Trump · stainless mullions", kit.material(0x9a9a9a));
+    const crown = kit.batch("Trump · crown", kit.material(0xffffff, { vertexColors: true }));
+    const fins = kit.batch("Trump · crown mullions", kit.material(0x8c8c8c));
+    const spire = kit.batch("Trump · spire", kit.material(0xd0d0d0));
+    const base = form.base;
+    const y = (real) => real - base;
+    const clamp = (real) => Math.max(real, base);
+    // The tiers, each a closed solid on the one below. The shaft stands to the shoulder all
+    // round, and its south part carries on to the roof.
+    const shaft = form.tiers.length - 1;
+    const bottoms = form.tiers.map((_, i) => (i === 0 ? 0 : form.tiers[i - 1].top));
+    const { shaft: shaftOutline, cap, crown: crownOutline } = topOutlines(form.tiers[shaft].outline, form.step, form.crown);
+    const outlines = form.tiers.map(({ outline }, i) => (i === shaft ? shaftOutline : orient(outline)));
+    const tops = form.tiers.map(({ top }, i) => (i === shaft ? h.shoulder : top));
+    const capPlan = planOf(cap);
+    outlines.forEach((outline, i) => { if (tops[i] > base)
+        kit.prism(shell, planOf(outline), [y(clamp(bottoms[i])), y(tops[i])]); });
+    if (h.roof > base)
+        kit.prism(shell, capPlan, [y(clamp(h.shoulder)), y(h.roof)]);
+    const wallRows = (from, to) => {
+        const rows = [{ lo: 0.4, hi: floorLines[0] - spandrelBelow, glass: true, floor: 0 }];
+        floorLines.forEach((line, i) => {
+            const next = floorLines[i + 1];
+            rows.push({ lo: line - spandrelBelow, hi: line + spandrelAbove, glass: false, floor: i + 1 });
+            rows.push({ lo: line + spandrelAbove, hi: next === undefined ? h.crownTop + 10 : next - spandrelBelow, glass: true, floor: i + 1 });
+        });
+        if (to <= from)
+            return [];
+        return rows.filter((row) => row.hi > from + 1e-6 && row.lo < to - 1e-6).map((row) => ({ ...row, lo: Math.max(row.lo, from), hi: Math.min(row.hi, to) }));
+    };
+    // A curtain wall on every run of an outline from `from` to the run's top: mullions one
+    // module apart along each wall, and between them glass and spandrel cells two modules
+    // wide, in one mitred skin along each stretch of a wall that starts and stops at the same
+    // heights. A skin starts just above its mullions, so their undersides never share a plane.
+    const curtainWall = (outline, runFrom, runTop, cells, frames, paint, seed) => {
+        const plan = planOf(outline);
+        chainsOf(plan, bend).forEach((chain, wall) => {
+            const stations = mullionStations(chain.length), columns = stations.filter((_, i) => i % 2 === 0);
+            const froms = chain.runs.map((index) => clamp(runFrom(plan[index])));
+            const ceilings = chain.runs.map((index) => runTop(plan[index]));
+            for (let k0 = 0; k0 < chain.runs.length;) {
+                let k1 = k0;
+                while (k1 + 1 < chain.runs.length && froms[k1 + 1] === froms[k0] && ceilings[k1 + 1] === ceilings[k0])
+                    k1 += 1;
+                const rows = wallRows(froms[k0] + 0.1, ceilings[k0]);
+                // At a wall's ends the glass stops short of a concave corner by the wedge its depth
+                // would push into the neighbouring wall's glass, and where a stretch meets one that
+                // something stands on, such as the crown on the step, it stops well clear of that.
+                const cornerTrim = (turn) => (turn > 0 ? 0.08 * Math.tan(turn / 2) + 0.005 : 0);
+                const s0 = chain.starts[k0] + (k0 === 0 ? cornerTrim(turnsAt(plan, chain.runs[0])[0]) : jointTrim(plan, chain, froms, k0, k0 - 1, clearance));
+                const s1 = chain.starts[k1] + plan[chain.runs[k1]].length - (k1 === chain.runs.length - 1 ? cornerTrim(turnsAt(plan, chain.runs[k1])[1]) : jointTrim(plan, chain, froms, k1, k1 + 1, clearance));
+                if (rows.length && s1 - s0 > 0.05) {
+                    chainSkin(kit, cells, plan, chain, k0, k1, s0, s1, columns, [rows[0].lo, ...rows.map((row) => row.hi)], 0.02, 0.07, (bay, r) => paint(rows[r], bay, seed + wall), spandrel, y);
+                }
+                k0 = k1 + 1;
+            }
+            // Each mullion stands whole on one run and stops short of the glass's top.
+            for (const { k, s } of mullionsOn(plan, chain, froms)) {
+                const run = plan[chain.runs[k]], from = Math.max(froms[k], 0.3), top = ceilings[k] - 0.1;
+                if (from < top)
+                    kit.box(frames, run.at(s), run.normal(0), mullionHalf, 0, mullionDepth, y(from), y(top));
+            }
+        });
+    };
+    const towerPaint = (row, bay, wall) => (row.glass ? paneColor(row.floor, bay, wall) : spandrel);
+    outlines.forEach((outline, i) => {
+        if (tops[i] <= base)
+            return;
+        // The shaft's south runs carry on to the roof.
+        const southOf = (run) => i === shaft && run.at(run.length / 2)[1] > form.step + 1e-6;
+        curtainWall(outline, () => bottoms[i], (run) => (southOf(run) ? h.roof : tops[i]), glazing, mullions, towerPaint, 10 * i);
+    });
+    // The step's north face, between the shoulder and the roof, is glazed like the rest where
+    // the crown does not stand on it; the cap's other walls are the shaft's own, glazed above.
+    const onStep = (run) => Math.abs(run.at(0)[1] - form.step) < 1e-6 && Math.abs(run.at(run.length)[1] - form.step) < 1e-6;
+    const underCrown = (run) => inside(crownOutline, run.at(run.length / 2, 0.3));
+    curtainWall(cap, (run) => (onStep(run) && !underCrown(run) ? h.shoulder : h.roof), () => h.roof, glazing, mullions, towerPaint, 90);
+    // The crown: a darker glazed enclosure on the same curtain wall, from whichever roof it
+    // stands on, capped flat. Its walls start above the roof around them.
+    // The crown's outline breaks at the step too, so each of its walls starts above one roof.
+    const crownPlan = planOf(crownOutline);
+    // Its solid sinks half a metre into the shaft, clear of the roofs' planes.
+    kit.prism(shell, crownPlan, [y(clamp(h.shoulder - 0.5)), y(h.crownTop)]);
+    const crownPaint = (row) => (row.glass ? crownGlass : crownBand);
+    curtainWall(crownOutline, crownFoot(cap), () => h.crownTop, crown, fins, crownPaint, 100);
+    // The spire: three stacked twelve-sided sections, each capped by a fan from its axis, the
+    // joints and the tip where the photograph shows them.
+    const [sx, sz] = form.spire, sides = 12;
+    const section = (radius, lo, hi) => {
+        const ring = (v) => Array.from({ length: sides }, (_, i) => { const a = (i + 0.5) * 2 * Math.PI / sides; return [sx + radius * Math.cos(a), y(v), sz - radius * Math.sin(a)]; });
+        const [foot, head] = [ring(lo), ring(hi)];
+        for (let i = 0; i < sides; i += 1) {
+            const j = (i + 1) % sides, a = (i + 1) * 2 * Math.PI / sides, out = [Math.cos(a), 0, -Math.sin(a)];
+            kit.quad(spire, [foot[i], foot[j], head[j], head[i]], [out]);
+            kit.triangle(spire, [[sx, y(hi), sz], head[i], head[j]], [[0, 1, 0], [0, 1, 0], [0, 1, 0]]);
+            kit.triangle(spire, [[sx, y(lo), sz], foot[j], foot[i]], [[0, -1, 0], [0, -1, 0], [0, -1, 0]]);
+        }
+    };
+    section(1.45, h.crownTop, h.joints[0]);
+    section(1.05, h.joints[0], h.joints[1]);
+    section(0.75, h.joints[1], h.tip);
+    return kit.finish({ height: y(h.tip), outlines: [shell, crown], opacity: 0.2 });
+}

package/site/models/two-illinois-center-geographic.js

@@ -0,0 +1,85 @@
+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";
+// Two Illinois Center, 233 North Michigan Avenue (Fujikawa Johnson & Associates, after Mies
+// van der Rohe's One Illinois Center, 1972): the geographic layout's model, on the mapped
+// outline 236770799. The original layout has no model of it. From the photograph's camera it
+// stands between Two Prudential Plaza and Aon Center, in front of River Plaza, and its lit
+// floors fill the lower part of the gap the drawing's `office-west-of-aon` group paints.
+//
+// A dark slab of 32 storeys: a curtain wall of mullions on a 5 ft module, glass over a
+// spandrel on every floor, and the top two floors' mechanical band, dark panels in place of
+// glass, under a flat roof at the published 114.3 m. The floor pitch is the photograph's; see
+// docs/river-plaza-two-illinois-center-reference.md. Units are meters; +x is east, +z is
+// south.
+export const twoIllinoisLevels = Object.freeze({
+    lobby: 4.25, // the lobby's height, what 31 floors at the pitch leave under the roof
+    pitch: 3.55, // each floor above it, measured on the photograph
+    plant: 31, // the first of the two mechanical floors
+    roof: 114.3, // the published height, the Skyscraper Center's 375 ft
+    module: 1.524, // the curtain wall's 5 ft module
+});
+const h = twoIllinoisLevels;
+const floor = (n) => (n < 2 ? 0 : h.lobby + (n - 2) * h.pitch);
+// The skins' colours: the window tones, and the mullions, spandrels and mechanical panels,
+// which no window shares.
+export const twoIllinoisPalette = Object.freeze({ glass: [0x1f1f1f, 0x232323, 0x272727, 0x1c1c1c], lit: 0x7a7a7a, dim: 0x4a4a4a, mullion: 0x333333, spandrel: 0x2b2b2b, plant: 0x303030 });
+const palette = twoIllinoisPalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim);
+const mullion = color(palette.mullion), spandrel = color(palette.spandrel), plant = color(palette.plant);
+const core = color(0x1a1a1a), roofing = color(0x303030);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 53, 0x9e3779b1) ^ Math.imul(bay + 23, 0x85ebca77) ^ Math.imul(wall + 71, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 9)
+        return litGlass;
+    if (value < 14)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+export const twoIllinoisRows = [{ lo: 0.25, hi: h.lobby, kind: "glass", floor: 1 }];
+for (let n = 2; n < h.plant; n += 1) {
+    twoIllinoisRows.push({ lo: floor(n), hi: floor(n) + 0.9, kind: "spandrel", floor: n });
+    twoIllinoisRows.push({ lo: floor(n) + 0.9, hi: floor(n + 1), kind: "glass", floor: n });
+}
+twoIllinoisRows.push({ lo: floor(h.plant), hi: h.roof, kind: "plant", floor: h.plant });
+const rows = twoIllinoisRows;
+export function createTwoIllinoisCenterGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Two Illinois Center · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Two Illinois Center · curtain wall", kit.material(0xffffff, { vertexColors: true }));
+    const lot = orient(polygonOf(projectPlan(record.footprint.coordinates)));
+    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);
+    // Every face's curtain wall, one box to a chain, held 2 cm clear of its ends or 9 cm where
+    // the outline turns in: a 10 cm mullion on each 5 ft module, from the chain's middle out,
+    // with glass or spandrel between.
+    const plan = planOf(lot), heights = [rows[0].lo, ...rows.map((row) => row.hi)];
+    chainsOf(plan).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.floor(chain.length / 2 / h.module);
+        const lines = Array.from({ length: 2 * count + 1 }, (_, k) => chain.length / 2 + (k - count) * h.module);
+        const cuts = lines.flatMap((c) => [c - 0.05, c + 0.05]).filter((s) => s > s0 + 0.01 && s < s1 - 0.01);
+        const columns = [s0, ...cuts, s1];
+        chainSkin(kit, wall, plan, chain, 0, chain.runs.length - 1, s0, s1, columns, heights, 0.02, 0.08, (bay, r) => {
+            const row = rows[r], middle = (columns[bay - 1] + columns[bay]) / 2;
+            if (lines.some((c) => Math.abs(middle - c) < 0.05))
+                return mullion;
+            if (row.kind === "plant")
+                return plant;
+            return row.kind === "spandrel" ? spandrel : paneColor(row.floor, bay, index);
+        }, mullion);
+    });
+    const model = kit.finish({ height: h.roof, 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/river-plaza-two-illinois-center-reference.md" };
+    return model;
+}