@a2f0/skyline 0.0.0-stage → 0.1.1

package/site/models/on-the-park-geographic.js

@@ -0,0 +1,245 @@
+import * as THREE from "../vendor/three-r186.js";
+import { arc, createBuilder, inside, polygonOf } from "./building-kit.js";
+import { chainSkin, chainsOf, mitredBox, orient, paintedSlab, planOf, turnsAt } from "./facade-grid.js";
+// 340 on the Park, 340 East Randolph Street (Solomon Cordwell Buenz, 2007): the geographic
+// layout's model, on the mapped outline 95486949 and its parts 284789056 and 284789058. The
+// original layout has no model of it; the drawing shows it right of the Blue Cross and Blue
+// Shield Tower, outside the excerpt it is fitted to.
+//
+// A glass tower on a straight south face, a diagonal south-east face and a north face
+// curved to keep The Buckingham's views. A white concrete frame stands on the south face:
+// piers, a beam every fifth floor, and a parapet band over four penthouse floors, with a
+// ladder of cantilevered balconies inside its west pier and recessed balconies inside its
+// east one. The two-and-a-half-storey winter garden fills the bay over the one deeper
+// beam. A glazed block fills the foot of the diagonal face, up to the top of floor 16's
+// beam. Floors are counted one by one from the lobby. Heights are measured on the drawing
+// down from the published 204.9 m top; see docs/340-on-the-park-reference.md. Units are
+// meters; +x is east, +z is south.
+export const onTheParkLevels = Object.freeze({
+    lowestBeam: 21.35, // floor 6's beam, the drawing's lowest
+    topBeam: 184.2, // floor 61's, under the penthouses
+    band: 198.6, // the parapet band's foot, over the fourth penthouse floor
+    roof: 203.8, // the band's top and the roof deck
+    top: 204.9, // the glass guard's top, the published architectural height
+    beam: 1.45, // a beam's depth; the winter garden's is 2.2 m
+});
+const h = onTheParkLevels;
+const pitch = (h.topBeam - h.lowestBeam) / 55, penthouse = (h.band - h.topBeam) / 4;
+// Each floor's level, from the second, over the lobby, to a 65th at the band's foot.
+const floor = (n) => (n <= 61 ? h.lowestBeam + (n - 6) * pitch : h.topBeam + (n - 61) * penthouse);
+const beamFloors = Array.from({ length: 12 }, (_, k) => 6 + 5 * k), garden = 26;
+// Floors whose west bay, the windows' column and the ladder, holds recessed balconies: the
+// two over the winter garden's tall row and the penthouses.
+const westRecessed = (n) => n === garden + 3 || n === garden + 4 || n >= 61;
+const beamSpan = (n) => { const half = (n === garden ? 2.2 : h.beam) / 2; return [floor(n) - half, floor(n) + half]; };
+// The corner block's roof, level with the top of floor 16's beam.
+const podiumTop = beamSpan(16)[1];
+const color = (hex) => new THREE.Color(hex);
+const glassTones = [0x2c2c2c, 0x303030, 0x343434, 0x383838].map(color);
+const litGlass = color(0x7a7a7a), dimGlass = color(0x4a4a4a);
+const slab = color(0x2a2a2a), recess = color(0x242424), lobby = color(0x3a3a3a), plant = color(0x303030);
+const concrete = color(0xb4b4b4), core = color(0x262626), roofing = color(0x3a3a3a);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 17, 0x9e3779b1) ^ Math.imul(bay + 41, 0x85ebca77) ^ Math.imul(wall + 29, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 4)
+        return litGlass;
+    if (value < 8)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+function rowsTo(top, { gardenRow = false, foot = 0.25 } = {}) {
+    const rows = [];
+    const push = (lo, hi, kind, n) => {
+        const [a, b] = [Math.max(lo, rows.at(-1)?.hi ?? foot), Math.min(hi, top)];
+        if (b - a > 1e-6)
+            rows.push({ lo: a, hi: b, kind, floor: n });
+    };
+    push(foot, floor(2) - 0.3, "lobby", 1);
+    for (let n = 2; n <= 64; n += 1) {
+        if (gardenRow && n > garden && n < garden + 3)
+            continue;
+        push(floor(n) - 0.3, floor(n) + 0.3, "slab", n);
+        push(floor(n) + 0.3, floor(gardenRow && n === garden ? n + 3 : n + 1) - 0.3, "glass", n);
+    }
+    push(floor(65) - 0.3, floor(65) + 0.3, "slab", 65);
+    push(floor(65) + 0.3, top, "plant", 65);
+    return rows;
+}
+export function createOnTheParkGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("340 on the Park · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("340 on the Park · curtain wall", kit.material(0xffffff, { vertexColors: true }));
+    const frame = kit.batch("340 on the Park · concrete frame", kit.material(0xb4b4b4));
+    const rails = kit.batch("340 on the Park · railings and guards", kit.material(0x7c7c7c));
+    const outline = (way) => orient(polygonOf(projectPlan(record.parts.find((part) => part.way === way).coordinates)));
+    const tower = outline(284789056), podium = outline(284789058);
+    // A solid on an outline between two heights, its walls the shell's dark core.
+    const solid = (corners, lo, hi) => {
+        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]]], core);
+        });
+        paintedSlab(kit, shell, corners, lo, false, roofing);
+        paintedSlab(kit, shell, corners, hi, true, roofing);
+    };
+    solid(tower, 0, h.roof);
+    solid(podium, 0, podiumTop);
+    // Whether a run lies along an outline's edges, and whether the corner block 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) => inside(podium, run.at(run.length / 2, 0.5));
+    // A cell is painted by its row and by where its middle stands along the wall: `recessed`
+    // marks glass in a balcony's shadow and `white` white wall.
+    const paint = (cuts, face, recessed = (_s, _row) => false, white = (_s, _row) => false) => (s, r) => {
+        const row = cuts[r];
+        if (row.kind === "lobby")
+            return lobby;
+        if (row.kind === "plant")
+            return plant;
+        if (row.kind === "slab")
+            return white(s, row) ? concrete : slab;
+        return recessed(s, row) ? recess : white(s, row) ? concrete : paneColor(row.floor, Math.round(s / 3), face);
+    };
+    // A wall's skin, on the runs `keep` accepts: cells about two 5 ft modules wide on every
+    // row. Each unbroken stretch of kept runs along a chain is one box, 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.
+    const skin = (corners, cuts, seed, keep) => {
+        const plan = planOf(corners), heights = [cuts[0].lo, ...cuts.map((row) => row.hi)];
+        chainsOf(plan).forEach((chain, index) => {
+            const count = Math.max(1, Math.round(chain.length / 3.048));
+            const columns = Array.from({ length: count + 1 }, (_, i) => chain.length * i / 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 clear = (k, end) => (turnsAt(plan, chain.runs[k])[end] > 0 && (end ? k === chain.runs.length - 1 : k === 0) ? 0.09 : 0.02);
+                const s0 = chain.starts[k0] + clear(k0, 0), s1 = chain.starts[k1] + plan[chain.runs[k1]].length - clear(k1, 1);
+                const colour = paint(cuts, seed * 8 + index);
+                chainSkin(kit, wall, plan, chain, k0, k1, s0, s1, columns, heights, 0.02, 0.07, (bay, r) => colour(((columns[bay - 1] ?? s0) + (columns[bay] ?? s1)) / 2, r), slab);
+                k0 = kept.indexOf(true, k1 + 1);
+            }
+        });
+    };
+    // The south face and its frame, laid out from the photograph, west to east: a 1.92 m pier,
+    // a column of windows, the balcony ladder, a 2.24 m pier, the glass field, the recessed
+    // balconies and a 2.24 m pier at the face's east end.
+    const facesSouth = (run) => run.normal(0)[1] > 0.99 && run.length > 40;
+    const plan = planOf(tower), chains = chainsOf(plan);
+    const southChain = chains.find((chain) => chain.runs.length === 1 && facesSouth(plan[chain.runs[0]]));
+    const south = plan[southChain.runs[0]], L = south.length, n = south.normal(0);
+    const westFirst = south.at(0)[0] < south.at(L)[0], scale = L / 43.2;
+    const along = (s) => (westFirst ? s * scale : L - s * scale);
+    const at = (s0, s1) => south.at((along(s0) + along(s1)) / 2);
+    const half = (s0, s1) => Math.abs(along(s1) - along(s0)) / 2;
+    const between = (s, a, b) => { const x = westFirst ? s / scale : (L - s) / scale; return x >= a - 1e-6 && x < b - 1e-6; };
+    const piers = [[0, 1.92], [8.0, 10.24], [40.96, 43.2]];
+    const [ladder, field, balconies] = [[4.8, 8.0], [10.24, 34.24], [34.24, 40.96]];
+    // The south face's skin in three boxes that meet under the inner and east piers, running
+    // on behind the band to the roof so the piers' tops never share its top's plane. The
+    // middle one carries the winter garden's tall row; the column of windows is punched in
+    // white wall, with 25 cm jambs either side, and the balconies' glass stands in shadow. Over
+    // the winter garden and on the penthouse floors the windows give way to balconies too.
+    const southRows = rowsTo(h.roof), gardenRows = rowsTo(h.roof, { gardenRow: true });
+    const southColumns = [0, 1.92, 2.17, 4.55, 4.8, 6.4, 8.0, 9.12, 10.24, ...Array.from({ length: 8 }, (_, i) => 13.24 + 3 * i), 35.92, 37.6, 39.28, 40.96, 42.08, 43.2].map(along).sort((a, b) => a - b);
+    const sections = [[0, 9.12, southRows], [9.12, 42.08, gardenRows], [42.08, 43.2, southRows]];
+    sections.forEach(([a, b, cuts], i) => {
+        const [s0, s1] = [Math.min(along(a), along(b)), Math.max(along(a), along(b))];
+        const colour = paint(cuts, i, (s, row) => between(s, ...ladder) || between(s, ...balconies) || (westRecessed(row.floor) && between(s, 1.92, 4.8)), (s, row) => (row.kind === "slab" ? between(s, 1.92, 4.8) : !westRecessed(row.floor) && (between(s, 1.92, 2.17) || between(s, 4.55, 4.8))));
+        const inset = (s, end) => (s < 0.01 || s > L - 0.01 ? (end ? -0.02 : 0.02) : end ? -0.01 : 0.01);
+        chainSkin(kit, wall, plan, southChain, 0, 0, s0 + inset(s0, false), s1 + inset(s1, true), southColumns, [cuts[0].lo, ...cuts.map((row) => row.hi)], 0.02, 0.07, (bay, r) => colour(((southColumns[bay - 1] ?? s0) + (southColumns[bay] ?? s1)) / 2, r), slab);
+    });
+    // The frame: piers from above grade to the band, a beam every fifth floor between the
+    // inner and east piers, deeper under the winter garden, and the parapet band over all.
+    for (const [a, b] of piers)
+        kit.box(frame, at(a, b), n, half(a, b), 0.05, 0.6, 0.3, h.band);
+    for (const f of beamFloors) {
+        const [lo, hi] = beamSpan(f);
+        kit.box(frame, at(8.3, 42.9), n, half(8.3, 42.9), 0.07, 0.45, lo, hi);
+    }
+    kit.box(frame, at(0, 43.2), n, half(0, 43.2) - 0.001, 0.07, 0.65, h.band, h.roof);
+    // The ladder's cantilevered balconies, a slab and a glass railing on each floor to the
+    // 60th. Over the winter garden and on the penthouse floors, balconies recessed behind the
+    // frame's plane cross the windows' column and the ladder instead.
+    for (let f = 2; f <= 64; f += 1) {
+        if (!westRecessed(f)) {
+            kit.box(frame, at(...ladder), n, half(...ladder), 0.07, 1.5, floor(f) - 0.15, floor(f) + 0.15);
+            kit.box(rails, at(...ladder), n, half(...ladder) - 0.05, 1.37, 1.45, floor(f) + 0.15, floor(f) + 1.05);
+            continue;
+        }
+        kit.box(frame, at(1.92, ladder[1]), n, half(1.92, ladder[1]), 0.07, 0.3, floor(f) - 0.15, floor(f) + 0.15);
+        kit.box(rails, at(1.92, ladder[1]), n, half(1.92, ladder[1]), 0.22, 0.28, floor(f) + 0.15, floor(f) + 1.05);
+    }
+    // Railings on the frame's plane: the recessed balconies on every floor but the winter
+    // garden's, and across the glass field on the garden's floors and the penthouses'. A
+    // railing stands on its floor's slab edge, or 2 cm over the beam where one crosses, clear
+    // of the feet of the columns and posts it passes.
+    for (let f = 2; f <= 64; f += 1) {
+        if (f > garden && f < garden + 3)
+            continue;
+        const wide = f === garden || f === garden + 3 || f === garden + 4 || f >= 61;
+        const [a, b] = wide ? [field[0], balconies[1]] : balconies;
+        const base = beamFloors.includes(f) ? beamSpan(f)[1] + 0.02 : floor(f) + 0.15;
+        if (!beamFloors.includes(f))
+            kit.box(frame, at(a, b), n, half(a, b), 0.07, 0.3, floor(f) - 0.15, floor(f) + 0.15);
+        kit.box(rails, at(a, b), n, half(a, b), 0.22, 0.28, base, base + 0.9);
+    }
+    // Three round columns through the winter garden's bay, and square posts at the same
+    // stations through the penthouses.
+    for (const s of [17.3, 25.6, 33.9]) {
+        const c = south.at(along(s), 0.62);
+        kit.prism(frame, [arc(c, 0.45, 0, 2 * Math.PI, false, Math.PI / 6)], [beamSpan(garden)[1], beamSpan(garden + 5)[0]]);
+        kit.box(frame, south.at(along(s)), n, 0.3, 0.05, 0.6, beamSpan(61)[1], h.band);
+    }
+    // The other walls: glass to the roof, the diagonal face's foot left to the corner block,
+    // which carries its own from a little higher so the two skins' feet never share a plane.
+    const plain = rowsTo(h.roof);
+    skin(tower, plain, 1, (run) => !facesSouth(run) && !covered(run) && !lies(run, podium));
+    skin(tower, plain.filter((row) => row.hi > podiumTop + 1e-6).map((row, i) => (i === 0 ? { ...row, lo: podiumTop } : row)), 2, covered);
+    skin(podium, rowsTo(podiumTop, { foot: 0.3 }), 3, (run) => !lies(run, tower));
+    // Fins at the beam floors and the top penthouse floor cross the diagonal face's last
+    // 8.6 m, where the drawing puts them, up to a white pier at the east tip.
+    const diagonal = chains.find((chain) => chain.runs.length === 2 && plan[chain.runs[0]].normal(0)[0] > 0.6);
+    const tipFirst = !covered(plan[diagonal.runs[0]]);
+    const [finFrom, finTo] = tipFirst ? [0, 8.6] : [diagonal.length - 8.6, diagonal.length];
+    diagonal.runs.forEach((index, k) => {
+        const run = plan[index], start = diagonal.starts[k];
+        const [s0, s1] = [Math.max(finFrom - start, 0), Math.min(finTo - start, run.length)];
+        if (s1 - s0 < 0.1)
+            return;
+        const [before, after] = turnsAt(plan, index);
+        for (const f of [...beamFloors, 64]) {
+            const [lo, hi] = [floor(f) - 0.35, floor(f) + 0.35];
+            if (covered(run) && lo < podiumTop)
+                continue;
+            mitredBox(kit, frame, run, s0, s1, s0 < 1e-6 ? before : undefined, s1 > run.length - 1e-6 ? after : undefined, 0.3, lo, hi);
+        }
+    });
+    const tip = plan[diagonal.runs[tipFirst ? 0 : 1]];
+    kit.box(frame, tip.at(tipFirst ? 0.45 : tip.length - 0.45), tip.normal(0), 0.45, 0.05, 0.4, 0.3, h.roof - 0.1);
+    // Glass guards round the roof and the corner block's terrace. The terrace's stop 30 cm
+    // short of the tower, whose diagonal face meets the block's walls at acute corners and
+    // whose skin reaches just past them.
+    plan.forEach((run, i) => { const [before, after] = turnsAt(plan, i); mitredBox(kit, rails, run, 0, run.length, before, after, 0.06, h.roof, h.top); });
+    const block = planOf(podium);
+    block.forEach((run, i) => {
+        if (lies(run, tower))
+            return;
+        const [before, after] = turnsAt(block, i), ends = [lies(block[(i + block.length - 1) % block.length], tower), lies(block[(i + 1) % block.length], tower)];
+        mitredBox(kit, rails, run, ends[0] ? 0.3 : 0, run.length - (ends[1] ? 0.3 : 0), ends[0] ? undefined : before, ends[1] ? undefined : after, 0.06, podiumTop, podiumTop + 1.1);
+    });
+    const model = kit.finish({ height: h.top, outlines: [shell, frame], 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/340-on-the-park-reference.md" };
+    return model;
+}

package/site/models/one-prudential-geographic.js

@@ -0,0 +1,55 @@
+import { polygonOf } from "./building-kit.js";
+import { chainsOf, orient, planOf } from "./facade-grid.js";
+import { buildOnePrudentialTower, onePrudentialLevels } from "./one-prudential-tower.js";
+// One Prudential Plaza: the geographic layout's model, on the mapped tower part 685493609,
+// the east wing 685493610 wrapped round its east end, the west wing 685493612 round its
+// west and north, and the mast at the mapped antenna part 685493614's centre. The tower is
+// the shared generator in one-prudential-tower.ts, the same one the original layout's copy
+// uses. The map gives the wings levels but no heights: the east wing's roof is measured
+// on the photograph, and the west wing, which the photograph cannot see, keeps its three
+// levels' estimate. The penthouse stands on the mapped south face where the photograph
+// shows it. See docs/one-prudential-reference.md. Units are meters; +x is east, +z is south.
+export const onePrudentialGeographicLevels = Object.freeze({
+    roof: onePrudentialLevels.roof,
+    penthouseTop: onePrudentialLevels.penthouseTop, // published architectural height
+    mastTop: onePrudentialLevels.mastTop,
+    tip: onePrudentialLevels.tip, // published antenna tip
+    floors: onePrudentialLevels.floors,
+    eastWing: 56.4, // part 685493610: measured on the photograph; the map gives ten levels
+    westWing: 13.4, // part 685493612: three levels at 183.2/41, estimated
+});
+const h = onePrudentialGeographicLevels;
+export function createOnePrudentialGeographicBuilding(record, projectPlan, offset) {
+    const outline = (way) => polygonOf(projectPlan(record.parts.find((p) => p.way === way).coordinates));
+    const tower = orient(outline(685493609));
+    // The south face is the tower's wall facing most nearly south; the penthouse stands on
+    // its chord, 2.3 m in from its west end.
+    const plan = planOf(tower);
+    const south = chainsOf(plan).map(({ runs }) => [plan[runs[0]].at(0), plan[runs.at(-1)].at(plan[runs.at(-1)].length)])
+        .reduce((best, chord) => (chord[1][0] - chord[0][0] > best[1][0] - best[0][0] ? chord : best));
+    const length = Math.hypot(south[1][0] - south[0][0], south[1][1] - south[0][1]);
+    const along = [(south[1][0] - south[0][0]) / length, (south[1][1] - south[0][1]) / length];
+    const corner = [south[0][0] + along[0] * 2.3, south[0][1] + along[1] * 2.3];
+    // The mast at the mapped antenna's area centroid.
+    const ring = outline(685493614);
+    let twice = 0, cx = 0, cz = 0;
+    ring.forEach(([x, z], i) => {
+        const [x2, z2] = ring[(i + 1) % ring.length], cross = x * z2 - x2 * z;
+        twice += cross;
+        cx += (x + x2) * cross;
+        cz += (z + z2) * cross;
+    });
+    const model = buildOnePrudentialTower({
+        name: record.name,
+        id: record.id,
+        tower,
+        wings: [{ outline: outline(685493610), top: h.eastWing }, { outline: outline(685493612), top: h.westWing }],
+        penthouse: { corner, along, length: 50.1, depth: 12 },
+        mast: [cx / (3 * twice), cz / (3 * twice)],
+        base: 0,
+    });
+    model.building.position.set(offset[0], 0, offset[1]);
+    model.building.userData["geography"] = record;
+    model.building.userData["geographicDetail"] = { levels: h, floors: h.floors, source: "docs/one-prudential-reference.md" };
+    return model;
+}

package/site/models/one-prudential-plaza.js

@@ -0,0 +1,72 @@
+import { buildOnePrudentialTower, floorLevel, onePrudentialLevels, screenFins, wallStations, wingRibs } from "./one-prudential-tower.js";
+// One 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. one-prudential-tower.ts
+// builds it, and the geographic model on the mapped outlines.
+//
+// The plan is the mapped one squared to the slab's grid, keeping each mapped wall's length:
+// a 71.6 x 22.2 m slab, stepped out 2.9 m along the north of its west end, with a 29 x
+// 15.5 m annex behind it, and the east wing wrapped round its east end, 38.2 m on Randolph
+// and 60.4 m on Stetson. The west wing is lower than the drawing's datum, so this copy has
+// none. See docs/one-prudential-reference.md. Units are meters; +x is east and +z is south.
+const half = 71.6 / 2, south = 22.2 / 2, north = -south;
+// The tower's walls break where the wing meets them, as the mapped outline's do, so each
+// piece starts its windows above whatever covers it.
+const wingWest = 26, wingBack = 11.5;
+const tower = [[-half, south], [wingWest, south], [half, south], [half, north], [wingBack, north], [7, north], [7, -26.6], [-22, -26.6], [-22, north], [-38.7, north], [-38.7, 4.1], [-half, 4.1]];
+const wingSouth = south + 15, wingEast = wingWest + 38.2, wingNorth = wingSouth - 60.4;
+const eastWing = [[half, south], [wingWest, south], [wingWest, wingSouth], [wingEast, wingSouth], [wingEast, wingNorth], [wingBack, wingNorth], [wingBack, north], [half, north]];
+// The east wing's roof, measured on the photograph down from the tower's. The map gives the
+// wing ten levels and no height; its windows keep the tower's floors.
+export const onePrudentialWingTop = 56.4;
+// The penthouse starts 2.3 m in from the west end and runs 50.1 m along the south face,
+// 12 m deep; the mast stands 52.6 m along and 14.9 m behind that face, as mapped.
+const penthouse = { corner: [-half + 2.3, south], along: [1, 0], length: 50.1, depth: 12 };
+const mast = [-half + 52.6, south - 14.9];
+// The skyline drawing shows the slab from the photograph's treeline up, 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 onePrudentialSkylineBase = 40;
+export function createOnePrudentialPlazaBuilding() {
+    return buildOnePrudentialTower({ name: "One Prudential Plaza", id: "building-one-prudential-plaza", tower, wings: [{ outline: eastWing, top: onePrudentialWingTop }], penthouse, mast, base: onePrudentialSkylineBase });
+}
+// Features the skyline test projects against the drawing, in this copy's coordinates.
+const h = onePrudentialLevels;
+const at = ([x, z], real) => [x, real - onePrudentialSkylineBase, z];
+const southWall = wallStations(2 * half), eastWall = wallStations(2 * south);
+const [ribsSouth, ribsEast] = [wingRibs(wingEast - wingWest), wingRibs(wingSouth - wingNorth)];
+const windowCentre = (floor) => floorLevel(floor) + (h.sill + h.head) / 2;
+const penthouseEast = [penthouse.corner[0] + penthouse.length, south];
+export const onePrudentialFeatures = {
+    // The roof's corners and the observatory band's foot, on the walls' corner edges.
+    roofLeft: at([-half, south], h.roof),
+    roofNear: at([half, south], h.roof),
+    roofRight: at([half, north], h.roof),
+    bandFootLeft: at([-half, south], h.bandFoot),
+    bandFootNear: at([half, south], h.bandFoot),
+    // The penthouse's south face: the sign wall's top under the screen, and the screen's top.
+    penthouseTopWest: at(penthouse.corner, h.louverBottom),
+    penthouseTopEast: at(penthouseEast, h.louverBottom),
+    screenTopWest: at(penthouse.corner, h.penthouseTop),
+    screenTopEast: at(penthouseEast, h.penthouseTop),
+    // The drawing stops the mast at the tubular mast's top; WGN's slim antenna goes on above.
+    mastTip: at(mast, h.mastTop),
+    // A window on the south face, clear of every neighbour, for hover.
+    southFacade: at([-half + southWall.piers[12] + h.bay / 2, south + 0.07], windowCentre(30)),
+    wingSouthWest: at([wingWest, wingSouth], onePrudentialWingTop),
+    wingCorner: at([wingEast, wingSouth], onePrudentialWingTop),
+    wingEastEnd: at([wingEast, wingNorth], onePrudentialWingTop),
+    // What reaches furthest right on the wing: its coping's outer north-east corner, top and
+    // bottom, and its wall's foot there.
+    wingRibEdge: [at([wingEast + 0.35, wingNorth - 0.35], onePrudentialWingTop), at([wingEast + 0.35, wingNorth - 0.35], onePrudentialWingTop - 0.5), [wingEast, 0, wingNorth]],
+    // The interior piers, halfway out to their faces at mid-height, and the screen's fins and
+    // the wing's ribs likewise, so a sight line meets each before reaching its point.
+    southPiers: southWall.piers.map((s) => at([-half + s, south + 0.15], 120)),
+    eastPiers: eastWall.piers.map((s) => at([half + 0.15, south - s], 120)),
+    screenLouvers: screenFins(penthouse.length, true).map((s) => at([penthouse.corner[0] + s, south + 0.1], (h.louverBottom + h.penthouseTop) / 2)),
+    southRibs: ribsSouth.map((s) => at([wingWest + s, wingSouth + 0.15], 50)),
+    // The drawing shows twenty-four of the east wall's twenty-five; the last falls past its end.
+    eastRibs: ribsEast.slice(0, 24).map((s) => at([wingEast + 0.15, wingSouth - s], 50)),
+    // Window centres in the south face's fourth bay on six floors, the drawing's first row
+    // and every sixth below it.
+    floorRows: [40, 34, 28, 22, 16, 10].map((floor) => at([-half + southWall.piers[2] + h.bay / 2, south + 0.07], windowCentre(floor))),
+};

package/site/models/one-prudential-tower.js

@@ -0,0 +1,246 @@
+import * as THREE from "../vendor/three-r186.js";
+import { createBuilder, inside } from "./building-kit.js";
+import { chainPier, chainsOf, gridBox, jointTrim, mitredBox, orient, paintedSlab, planOf, turnsAt } from "./facade-grid.js";
+// Heights above the street. The penthouse top and the antenna tip are published, and the
+// antenna's length is WGN's. The roof, the observatory band, the penthouse's louvers, the
+// floor pitch, and the window rows are measured on the photograph the drawing was traced
+// from, down from the published penthouse top. See docs/one-prudential-reference.md.
+export const onePrudentialLevels = Object.freeze({
+    // The ground storey, then thirty-nine office floors, then the observatory: forty-one.
+    lobbyTop: 12.03,
+    pitch: 3.93,
+    floors: 41,
+    sill: 0.85,
+    head: 2.45,
+    sillCourse: 164.9,
+    bandFoot: 165.3,
+    copingFoot: 169,
+    roof: 169.5,
+    signBottom: 171,
+    signTop: 179.5,
+    louverBottom: 180.3,
+    penthouseTop: 183.2,
+    // The 311 ft tubular mast's top, where WGN's 73 ft antenna leaves its 12 ft socket.
+    mastTop: 259.4,
+    tip: 278,
+    bay: 2.35,
+});
+const h = onePrudentialLevels;
+// A floor's level: the ground floor at the street, the office floors from the lobby's top,
+// and the forty-first at the observatory band's foot.
+export const floorLevel = (floor) => (floor === 1 ? 0 : h.lobbyTop + (floor - 2) * h.pitch);
+// The facade module. Interior piers stand one bay apart, centred on the wall; the bays at
+// each end take what is left, at least `endBay`, and the corner pier widens to fill it, so
+// every window is the same width.
+const endBay = 2.6, pierHalf = 0.55, pierDepth = 0.3, ribHalf = 0.5;
+export function wallStations(length) {
+    const interior = Math.max(0, Math.floor((length - 2 * endBay) / h.bay));
+    const end = (length - interior * h.bay) / 2;
+    return { piers: Array.from({ length: interior + 1 }, (_, i) => end + i * h.bay), corner: end - h.bay + pierHalf };
+}
+// A wing's ribs: as many bays as the wall holds, centred on it.
+export function wingRibs(length) {
+    const count = Math.floor(length / h.bay);
+    return Array.from({ length: count }, (_, i) => length / 2 + (i - (count - 1) / 2) * h.bay);
+}
+// The screen's fins: the drawing's forty-nine on the south face, one every 0.98 m from 2.2 m
+// in; the other faces hold as many as fit, centred.
+const finPitch = 0.98, finHalf = 0.15, finDepth = 0.2;
+export function screenFins(length, front) {
+    if (front)
+        return Array.from({ length: 49 }, (_, i) => 2.2 + i * finPitch);
+    const count = Math.floor((length - 1) / finPitch) + 1;
+    return Array.from({ length: count }, (_, i) => length / 2 + (i - (count - 1) / 2) * finPitch);
+}
+// The sign, along the penthouse's south face: a board carrying the Rock of Gibraltar and
+// the name, ten letters from 14 m to 42.8 m, their capital and ascenders taller than the rest.
+const sign = { board: [4.6, 43.3], logo: [7.1, 13], rows: [172, 173.8, 177, 178.7], letters: 10, name: [14, 42.8], tall: new Set([0, 3, 6, 7, 9]) };
+const mastFoot = 1.15, mastHead = 0.5, antennaHalf = 0.22;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = [0x262626, 0x2c2c2c, 0x323232, 0x222222].map(color);
+const litGlass = color(0x7c7c7c), dimGlass = color(0x4e4e4e);
+const observatory = [0x3a3a3a, 0x444444, 0x404040].map(color), litObservatory = color(0x8a8a8a);
+const aluminium = color(0x8e8e8e), darkSpandrel = color(0x242424), limestone = color(0xb0b0b0), roofing = color(0x4c4c4c);
+const penthouseWall = color(0x9c9c9c), louverBacking = color(0x383838), board = color(0x2e2e2e), lettering = color(0xc4c4c4), logo = color(0xb0b0b0);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 5, 0x9e3779b1) ^ Math.imul(bay + 23, 0x85ebca77) ^ Math.imul(wall + 13, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 3)
+        return litGlass;
+    if (value < 6)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+function wallRows(from, to) {
+    const rows = [{ lo: 0.4, hi: h.lobbyTop - 0.9, kind: "glass", floor: 1 }];
+    for (let floor = 2; floor < h.floors; floor += 1) {
+        const level = floorLevel(floor);
+        rows.push({ lo: rows.at(-1).hi, hi: level + h.sill, kind: "spandrel", floor }, { lo: level + h.sill, hi: level + h.head, kind: "glass", floor });
+    }
+    rows.push({ lo: rows.at(-1).hi, hi: h.bandFoot, kind: "spandrel", floor: h.floors - 1 });
+    rows.push({ lo: h.bandFoot, hi: h.copingFoot, kind: "band", floor: h.floors });
+    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) }));
+}
+export function buildOnePrudentialTower(form) {
+    const kit = createBuilder(form.name, form.id);
+    const shell = kit.batch("One Prudential · shell", kit.material(0xffffff, { vertexColors: true }));
+    const glazing = kit.batch("One Prudential · windows and spandrels", kit.material(0xffffff, { vertexColors: true }));
+    const piers = kit.batch("One Prudential · limestone piers", kit.material(0xb4b4b4));
+    const bands = kit.batch("One Prudential · limestone courses", kit.material(0xc0c0c0));
+    const penthouse = kit.batch("One Prudential · penthouse and sign", kit.material(0xffffff, { vertexColors: true }));
+    const fins = kit.batch("One Prudential · screen louvers", kit.material(0x707070));
+    const mast = kit.batch("One Prudential · antenna mast", kit.material(0xb4b4b4));
+    const base = form.base;
+    const y = (real) => real - base;
+    const shown = (real) => real > base + 1e-6;
+    const tower = orient(form.tower), towerPlan = planOf(tower);
+    const wings = form.wings.filter(({ top }) => shown(top)).map(({ outline, top }) => ({ outline: orient(outline), plan: planOf(orient(outline)), top }));
+    // A wall is covered, up to a neighbour's roof, where a probe just outside it lands inside
+    // that neighbour: the tower covers its wings' inner walls, and the wings the tower's lower ones.
+    const parts = [{ outline: tower, top: h.roof }, ...wings.map(({ outline, top }) => ({ outline, top }))];
+    const coveredTo = (run, own) => Math.max(base, ...parts.filter(({ outline }) => outline !== own && inside(outline, run.at(run.length / 2, 0.3))).map(({ top }) => top));
+    const turns = turnsAt;
+    // The solids: walls, floors, and roofs, closed. Walls behind the facade are spandrel
+    // aluminium; a wall too short for a bay is plain limestone.
+    const solid = (outline, plan, top, paint) => {
+        plan.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], y(top), b[1]], [a[0], y(top), a[1]]], [[n[0], 0, n[1]]], paint(run));
+        });
+        paintedSlab(kit, shell, outline, 0, false, roofing);
+        paintedSlab(kit, shell, outline, y(top), true, roofing);
+    };
+    // Piers cross a chain's joints in pieces, and cells stop short of them: see chainPier and
+    // jointTrim in facade-grid.ts.
+    const trim = jointTrim;
+    const pierOn = (plan, chain, froms, a, b, depth, top) => chainPier(kit, piers, plan, chain, froms, a, b, depth, top, y);
+    // A run's cells start just above its piers, so their undersides never share a plane.
+    const cellsFrom = (from) => from + 0.1;
+    // The tower's walls. Each chain of nearly collinear runs is one wall with one set of
+    // piers; a run's windows start above whatever wing covers it.
+    const towerChains = chainsOf(towerPlan);
+    const plainRuns = new Set(towerChains.filter(({ length }) => length < 2 * endBay).flatMap(({ runs }) => runs));
+    solid(tower, towerPlan, h.roof, (run) => (plainRuns.has(towerPlan.indexOf(run)) ? limestone : aluminium));
+    towerChains.forEach((chain, wall) => {
+        if (chain.length < 2 * endBay)
+            return;
+        const { piers: stations, corner } = wallStations(chain.length);
+        const columns = [corner - 0.2, ...stations, chain.length - corner + 0.2];
+        const froms = chain.runs.map((index) => coveredTo(towerPlan[index], tower));
+        chain.runs.forEach((index, k) => {
+            const run = towerPlan[index], start = chain.starts[k], end = start + run.length;
+            const rows = wallRows(cellsFrom(froms[k]), h.copingFoot);
+            // Windows and spandrels: one box on the run, a column per bay and a row per window,
+            // spandrel, and the observatory band.
+            const first = Math.max(columns[0], start + trim(towerPlan, chain, froms, k, k - 1)), last = Math.min(columns.at(-1), end - trim(towerPlan, chain, froms, k, k + 1));
+            const local = [first, ...columns.filter((s) => s > first + 1e-6 && s < last - 1e-6), last];
+            const offset = columns.filter((s) => s <= first + 1e-6).length - 1;
+            if (last - first < 0.05 || !rows.length)
+                return;
+            gridBox(kit, glazing, run, local.map((s) => s - start), [rows[0].lo, ...rows.map((row) => row.hi)], 0.02, 0.07, (column, r) => {
+                const row = rows[r], bay = offset + column;
+                if (row.kind === "spandrel")
+                    return aluminium;
+                if (row.kind === "band")
+                    return paneColor(row.floor, bay, wall).equals(litGlass) ? litObservatory : observatory[bay % observatory.length];
+                return paneColor(row.floor, bay, wall);
+            }, aluminium, y);
+        });
+        // The piers, from the street to the sill course, standing proud of the glass: one on
+        // every bay line, and a wider one at each corner.
+        for (const s of stations)
+            pierOn(towerPlan, chain, froms, s - pierHalf, s + pierHalf, pierDepth, h.sillCourse);
+        pierOn(towerPlan, chain, froms, 0, corner, pierDepth, h.sillCourse);
+        pierOn(towerPlan, chain, froms, chain.length - corner, chain.length, pierDepth, h.sillCourse);
+    });
+    // The limestone sill course under the observatory and the coping over it, round every run.
+    towerPlan.forEach((run, index) => {
+        const [before, after] = turns(towerPlan, index);
+        if (shown(h.bandFoot))
+            mitredBox(kit, bands, run, 0, run.length, before, after, pierDepth, Math.max(h.sillCourse, base), h.bandFoot, y);
+        if (shown(h.roof))
+            mitredBox(kit, bands, run, 0, run.length, before, after, 0.35, Math.max(h.copingFoot, base), h.roof, y);
+    });
+    // The wings: dark spandrels between limestone ribs on the same module, a window per bay
+    // on each floor, and a coping. Walls the tower covers carry nothing.
+    wings.forEach(({ outline, plan, top }, number) => {
+        solid(outline, plan, top, () => darkSpandrel);
+        // Where a wall meets the tower, its cells and coping stop clear of the tower's piers.
+        const coping = top - 0.5, clear = pierDepth + 0.05;
+        const open = plan.map((run) => coveredTo(run, outline) < coping);
+        chainsOf(plan).forEach((chain, wall) => {
+            const ribs = wingRibs(chain.length);
+            const froms = chain.runs.map((index) => (open[index] ? coveredTo(plan[index], outline) : top));
+            chain.runs.forEach((index, k) => {
+                const run = plan[index], start = chain.starts[k];
+                // The cells stop under the coping, clear of the ribs' tops.
+                const rows = wallRows(cellsFrom(froms[k]), coping - 0.05).filter((row) => row.kind !== "band");
+                if (!open[index] || !rows.length)
+                    return;
+                // Cells stop short of a wall the tower covers, clear of the tower's piers in the corner.
+                const s0 = open[(index + plan.length - 1) % plan.length] ? trim(plan, chain, froms, k, k - 1) : clear;
+                const s1 = run.length - (open[(index + 1) % plan.length] ? trim(plan, chain, froms, k, k + 1) : clear);
+                const local = [s0, ...ribs.filter((s) => s > start + s0 + 1e-6 && s < start + s1 - 1e-6).map((s) => s - start), s1];
+                const offset = ribs.filter((s) => s <= start + 1e-6).length;
+                gridBox(kit, glazing, run, local, [rows[0].lo, ...rows.map((row) => row.hi)], 0.02, 0.07, (column, r) => (rows[r].kind === "glass" ? paneColor(rows[r].floor, offset + column, 40 + 10 * number + wall) : darkSpandrel), darkSpandrel, y);
+            });
+            for (const s of ribs)
+                pierOn(plan, chain, froms, s - ribHalf, s + ribHalf, pierDepth, coping);
+        });
+        // The coping, mitred between open walls. Against the tower it is mitred as if into a
+        // concave corner, its inner edge on the wall's own corners and its outer edge clear of
+        // the tower's piers.
+        plan.forEach((run, index) => {
+            if (!open[index])
+                return;
+            const [before, after] = turns(plan, index), quarter = Math.PI / 2;
+            mitredBox(kit, bands, run, 0, run.length, open[(index + plan.length - 1) % plan.length] ? before : quarter, open[(index + 1) % plan.length] ? after : quarter, 0.35, Math.max(coping, base), top, y);
+        });
+    });
+    // The penthouse: a pale wall carrying the sign, under a dark screen of limestone-grey fins.
+    const { corner, along, length, depth } = form.penthouse;
+    const inward = [along[1], -along[0]];
+    const offsetBy = ([x, z], s, d) => [x + along[0] * s + inward[0] * d, z + along[1] * s + inward[1] * d];
+    const penthouseOutline = orient([corner, offsetBy(corner, length, 0), offsetBy(corner, length, depth), offsetBy(corner, 0, depth)]);
+    const penthousePlan = planOf(penthouseOutline);
+    penthousePlan.forEach((run) => {
+        const a = run.at(0), b = run.at(run.length), n = run.normal(0), normal = [[n[0], 0, n[1]]];
+        const p = (q, v) => [q[0], y(v), q[1]];
+        kit.quad(penthouse, [p(a, h.roof), p(b, h.roof), p(b, h.louverBottom), p(a, h.louverBottom)], normal, penthouseWall);
+        kit.quad(penthouse, [p(a, h.louverBottom), p(b, h.louverBottom), p(b, h.penthouseTop), p(a, h.penthouseTop)], normal, louverBacking);
+        const front = n[1] > 0.9;
+        for (const s of screenFins(run.length, front))
+            kit.box(fins, run.at(s), n, finHalf, 0, finDepth, y(h.louverBottom + 0.15), y(h.penthouseTop - 0.15));
+        if (front) {
+            const pitch = (sign.name[1] - sign.name[0]) / sign.letters;
+            const letters = Array.from({ length: sign.letters }, (_, i) => [sign.name[0] + i * pitch + 0.25, sign.name[0] + (i + 1) * pitch - 0.25]).flat();
+            const columns = [sign.board[0], sign.logo[0], sign.logo[1], ...letters, sign.board[1]];
+            // Rows: the board's foot, the logo, the letters, the tall letters, the board's head.
+            gridBox(kit, penthouse, run, columns, [h.signBottom, ...sign.rows, h.signTop], 0.02, 0.25, (column, row) => {
+                if (column === 1)
+                    return row >= 1 && row <= 3 ? logo : board;
+                const letter = (column - 3) / 2;
+                if (column < 3 || !Number.isInteger(letter) || letter >= sign.letters)
+                    return board;
+                return row === 2 || (row === 3 && sign.tall.has(letter)) ? lettering : board;
+            }, board, y);
+        }
+    });
+    paintedSlab(kit, penthouse, penthouseOutline, y(h.roof), false, roofing);
+    paintedSlab(kit, penthouse, penthouseOutline, y(h.penthouseTop), true, roofing);
+    // The mast: an eight-sided steel tube tapering from the roof to its top, capped by a fan
+    // from its axis, and WGN's slim antenna on to the published tip.
+    const [mx, mz] = form.mast, sides = 8;
+    const ring = (radius, v) => Array.from({ length: sides }, (_, i) => { const a = (i + 0.5) * 2 * Math.PI / sides; return [mx + radius * Math.cos(a), y(v), mz - radius * Math.sin(a)]; });
+    const foot = ring(mastFoot, h.roof), head = ring(mastHead, h.mastTop);
+    // Each side leans in with the taper, so its normal tilts up by the apothem's fall per metre.
+    const lean = (mastFoot - mastHead) * Math.cos(Math.PI / sides) / (h.mastTop - h.roof);
+    for (let i = 0; i < sides; i += 1) {
+        const j = (i + 1) % sides, a = (i + 1) * 2 * Math.PI / sides, l = Math.hypot(1, lean), out = [Math.cos(a) / l, lean / l, -Math.sin(a) / l];
+        kit.quad(mast, [foot[i], foot[j], head[j], head[i]], [out]);
+        kit.triangle(mast, [[mx, y(h.mastTop), mz], head[i], head[j]], [[0, 1, 0], [0, 1, 0], [0, 1, 0]]);
+        kit.triangle(mast, [[mx, y(h.roof), mz], foot[j], foot[i]], [[0, -1, 0], [0, -1, 0], [0, -1, 0]]);
+    }
+    kit.box(mast, form.mast, [0, 1], antennaHalf, -antennaHalf, antennaHalf, y(h.mastTop), y(h.tip));
+    return kit.finish({ height: y(h.tip), outlines: [shell, bands], opacity: 0.18 });
+}