@a2f0/skyline 0.0.0-stage → 0.1.1

package/lib/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/lib/models/trump-tower.d.ts

@@ -0,0 +1,43 @@
+import type { BuildingModel, Run, Vec2 } from "./building-kit.js";
+export interface TrumpForm {
+    name: string;
+    id: string;
+    tiers: {
+        outline: Vec2[];
+        top: number;
+    }[];
+    step: number;
+    crown: Vec2[];
+    spire: Vec2;
+    base: number;
+}
+export declare const trumpLevels: Readonly<{
+    podium: 60;
+    setbacks: readonly [120, 200];
+    roof: 354.4;
+    shoulder: 347.3;
+    crownTop: 364.9;
+    joints: readonly [377.4, 402.2];
+    tip: 423.2;
+    floorLine: 187.01;
+    pitch: 3.214;
+    lobbyTop: 10.5;
+    module: 1.8288;
+}>;
+export declare const floorLines: number[];
+export declare function mullionStations(length: number): number[];
+export declare function mullionPoints(corners: Vec2[], runFrom: (run: Run) => number): {
+    at: Vec2;
+    normal: Vec2;
+}[];
+export declare function splitAt(corners: Vec2[], z: number): {
+    outline: Vec2[];
+    south: Vec2[];
+};
+export declare function topOutlines(shaftCorners: Vec2[], step: number, crownCorners: Vec2[]): {
+    shaft: Vec2[];
+    cap: Vec2[];
+    crown: Vec2[];
+};
+export declare const crownFoot: (cap: Vec2[]) => (run: Run) => 347.3 | 354.4;
+export declare function buildTrumpTower(form: TrumpForm): BuildingModel;

package/lib/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/lib/models/two-illinois-center-geographic.d.ts

@@ -0,0 +1,26 @@
+import type { BuildingModel, Plan } from "./building-kit.js";
+import type { GeoBuilding } from "./skyline-geography-data.js";
+export declare const twoIllinoisLevels: Readonly<{
+    lobby: 4.25;
+    pitch: 3.55;
+    plant: 31;
+    roof: 114.3;
+    module: 1.524;
+}>;
+export declare const twoIllinoisPalette: Readonly<{
+    glass: number[];
+    lit: 8026746;
+    dim: 4868682;
+    mullion: 3355443;
+    spandrel: 2829099;
+    plant: 3158064;
+}>;
+type Row = {
+    lo: number;
+    hi: number;
+    kind: "spandrel" | "glass" | "plant";
+    floor: number;
+};
+export declare const twoIllinoisRows: Row[];
+export declare function createTwoIllinoisCenterGeographicBuilding(record: GeoBuilding, projectPlan: (coordinates: [number, number][]) => Plan, offset: [number, number]): BuildingModel;
+export {};

package/lib/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;
+}

package/lib/models/two-prudential-geographic.d.ts

@@ -0,0 +1,25 @@
+import type { BuildingModel, Plan, Vec2 } from "./building-kit.js";
+import type { GeoBuilding } from "./skyline-geography-data.js";
+export declare const twoPrudentialGeographicLevels: Readonly<{
+    pitch: 3.96;
+    lobbyTop: 11.52;
+    sill: 0.9;
+    head: 2.9;
+    lowerShoulder: 162;
+    lowerPeak: number;
+    middleShoulder: 193.68;
+    middlePeak: number;
+    eave: 229.32;
+    peak: 256;
+    apex: 280.2;
+    shaftTop: 295.5;
+    tip: 303.3;
+    floors: 64;
+}>;
+export declare function areaCentroid(outline: Vec2[]): Vec2;
+export declare function twoPrudentialFrame(ground: Plan): {
+    centre: Vec2;
+    along: Vec2;
+    fronts: [number, number];
+};
+export declare function createTwoPrudentialGeographicBuilding(record: GeoBuilding, projectPlan: (coordinates: [number, number][]) => Plan, offset: [number, number]): BuildingModel;

package/lib/models/two-prudential-geographic.js

@@ -0,0 +1,47 @@
+import { polygonOf } from "./building-kit.js";
+import { chainsOf } from "./facade-grid.js";
+import { buildTwoPrudentialTower, twoPrudentialCore, twoPrudentialLevels } from "./two-prudential-tower.js";
+// Two Prudential Plaza: the geographic layout's model, on the mapped outline 64388666. The
+// tower is the shared generator in two-prudential-tower.ts, the same one the original
+// layout's copy uses. Its core stands on the outline's area centroid, square to the mapped
+// south wall; the lobby fills the mapped outline to the first office floor, and the tiers
+// fill the depth between the core and the mapped north and south walls. See
+// docs/two-prudential-reference.md. Units are meters; +x is east, +z is south.
+export const twoPrudentialGeographicLevels = twoPrudentialLevels;
+// The area centroid, not the mean of the traced vertices: this outline carries three extra
+// points down its west wall, which would pull a vertex mean 4.9 m west and 2.7 m south.
+export function areaCentroid(outline) {
+    let twice = 0, x = 0, z = 0;
+    outline.forEach((a, i) => {
+        const b = outline[(i + 1) % outline.length], cross = a[0] * b[1] - b[0] * a[1];
+        twice += cross;
+        x += (a[0] + b[0]) * cross;
+        z += (a[1] + b[1]) * cross;
+    });
+    return [x / (3 * twice), z / (3 * twice)];
+}
+// The core's frame on the mapped outline: its centre, the unit vector along the mapped south
+// wall, and how far the mapped south and north walls stand from the centre along its normal.
+export function twoPrudentialFrame(ground) {
+    const outline = polygonOf(ground), centre = areaCentroid(outline);
+    const chains = chainsOf(ground).map((chain) => ({ chain, normal: ground[chain.runs[0]].normal(0) }));
+    const wall = (sign) => chains.find(({ normal }) => normal[1] * sign > 0.9).chain;
+    const ends = (chain) => chain.runs.flatMap((index) => [ground[index].at(0), ground[index].at(ground[index].length)]);
+    const [start, end] = [ends(wall(1))[0], ends(wall(1)).at(-1)];
+    const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+    const along = [(end[0] - start[0]) / length, (end[1] - start[1]) / length], south = [-along[1], along[0]];
+    const depth = (p) => (p[0] - centre[0]) * south[0] + (p[1] - centre[1]) * south[1];
+    // The nearest point of each wall, less 2 cm, so each lower tier's front stays within the
+    // mapped outline across the whole of its width.
+    const fronts = [Math.min(...ends(wall(1)).map(depth)) - 0.02, Math.min(...ends(wall(-1)).map((p) => -depth(p))) - 0.02];
+    return { centre, along, fronts };
+}
+export function createTwoPrudentialGeographicBuilding(record, projectPlan, offset) {
+    const ground = projectPlan(record.footprint.coordinates);
+    const { centre, along, fronts } = twoPrudentialFrame(ground);
+    const model = buildTwoPrudentialTower({ name: record.name, id: record.id, centre, along, fronts, base: 0, lobby: ground });
+    model.building.position.set(offset[0], 0, offset[1]);
+    model.building.userData["geography"] = record;
+    model.building.userData["geographicDetail"] = { levels: twoPrudentialGeographicLevels, core: twoPrudentialCore, floors: twoPrudentialLevels.floors, source: "docs/two-prudential-reference.md" };
+    return model;
+}

package/lib/models/two-prudential-plaza.d.ts

@@ -0,0 +1,8 @@
+import type { BuildingModel, Vec3 } from "./building-kit.js";
+export declare const twoPrudentialSkylineBase = 35.4;
+export declare const twoPrudentialDrawnTierPeaks: Readonly<{
+    lower: 181.9;
+    middle: 217.2;
+}>;
+export declare function createTwoPrudentialPlazaBuilding(): BuildingModel;
+export declare const twoPrudentialFeatures: Record<string, Vec3 | Vec3[]>;

package/lib/models/two-prudential-plaza.js

@@ -0,0 +1,55 @@
+import { buildTwoPrudentialTower, pierStations, twoPrudentialCore, twoPrudentialGables, twoPrudentialLevels } from "./two-prudential-tower.js";
+// Two Prudential Plaza on a clean version of its plan, in real meters, for the skyline
+// study's original layout, which places this copy in skyline-study.ts. two-prudential-tower.ts
+// builds it, and the geographic model on the mapped outline. The plan is the mapped one
+// squared: the 40.8 x 37.5 m core, with each pair of tiers 4.5 m deep, so the lower tiers'
+// fronts stand 27.75 m either side of its centre and the tower keeps the mapped 55.5 m
+// depth. See docs/two-prudential-reference.md. Units are meters; +x is east and +z is south.
+const front = 27.75;
+// The skyline drawing shows the tower above One Prudential's podium, so 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 twoPrudentialSkylineBase = 35.4;
+// The drawing draws each tier's gable as one slope from its shoulders to a point about 2 m
+// above the line its steps climb: in the night photograph it traces, each tier's dark glass
+// head runs on into the dark strip of the wall behind it. This copy keeps the drawn points.
+export const twoPrudentialDrawnTierPeaks = Object.freeze({ lower: 181.9, middle: 217.2 });
+export function createTwoPrudentialPlazaBuilding() {
+    return buildTwoPrudentialTower({ name: "Two Prudential Plaza", id: "building-two-prudential-plaza", centre: [0, 0], along: [1, 0], fronts: [front, front], base: twoPrudentialSkylineBase, tierPeaks: twoPrudentialDrawnTierPeaks });
+}
+// Features the skyline test projects against the drawing, in this copy's coordinates.
+const h = twoPrudentialLevels, g = twoPrudentialGables, [coreA, coreB] = twoPrudentialCore, drawn = twoPrudentialDrawnTierPeaks;
+const at = (x, real, z) => [x, real - twoPrudentialSkylineBase, z];
+const middleFront = coreB + (front - coreB) / 2;
+// A pier's point halfway out to its face, so a present pier is met a little before it.
+const halfPier = 0.175;
+// Every pier across a gabled face, west to east, from its middle.
+const across = (gable) => { const stations = pierStations(gable); return [...stations.map((r) => -r), ...[...stations].reverse()]; };
+export const twoPrudentialFeatures = {
+    // The core's corners at the eave, and the points of its south and east gables.
+    twoEaveWest: at(-coreA, h.eave, coreB),
+    twoEaveNear: at(coreA, h.eave, coreB),
+    twoEaveEast: at(coreA, h.eave, -coreB),
+    twoSouthChevron: at(0, h.peak, coreB + 0.03),
+    twoEastChevron: at(coreA + 0.03, h.peak, 0),
+    twoPyramid: at(0, h.apex, 0),
+    twoSpire: at(0, h.tip, 0),
+    // The tiers' points and their shoulders at their fronts' corners.
+    twoMiddleChevron: at(0, drawn.middle, middleFront),
+    twoLowerChevron: at(0, drawn.lower, front),
+    twoMiddleWest: at(-g.middle.half, h.middleShoulder, middleFront),
+    twoMiddleEast: at(g.middle.half, h.middleShoulder, middleFront),
+    twoLowerWest: at(-g.lower.half, h.lowerShoulder, front),
+    twoLowerEast: at(g.lower.half, h.lowerShoulder, front),
+    // The core's south piers above the middle tier, all twelve.
+    twoSouthPiers: across(g.front).map((x) => at(x, 222, coreB + halfPier)),
+    // The east face's piers from its north corner, where the face's x runs north to south
+    // as z does: every one but the first south of the strip, which the drawing leaves out.
+    twoEastPiers: across(g.side).filter((_, index) => index !== 6).map((z) => at(coreA + halfPier, 204, z)),
+    // The lower tier's eight piers.
+    twoLowerPiers: across(g.lower).map((x) => at(x, 135, front + halfPier)),
+    // A window on the east face, clear of every neighbour, for hover.
+    twoFacade: at(coreA + 0.02, 180, -10.7),
+    // On the lower tier's front below the podium roof, which hides it: for scene raycasts.
+    twoBehindPodium: at(-10, 45, front),
+};