@a2f0/skyline 0.0.0-stage → 0.1.1

package/site/models/heritage-geographic.js

@@ -0,0 +1,208 @@
+import { createBuilder, inside, line, polygonOf, rectangle } from "./building-kit.js";
+// Meters, with east/+x and south/+z. Design elevations from PD 787, sheets
+// 63741/63743; occupied/tip heights from CTBUH. See the reference audit for
+// the distinction between the 2001 design drawings and the completed building.
+export const heritageGeographicLevels = Object.freeze({
+    podium: (107 + 8 / 12) * 0.3048,
+    lowerRoof: (293 + 8 / 12) * 0.3048,
+    occupied: 176.8,
+    mainRoof: (594 + 6 / 12) * 0.3048,
+    tip: 192.4,
+});
+export function heritageFloorHeight(floor) {
+    const h = heritageGeographicLevels;
+    return floor <= 28
+        ? h.podium + (floor - 9) * (h.lowerRoof - h.podium) / 19
+        : h.lowerRoof + (floor - 28) * (h.occupied - h.lowerRoof) / 29;
+}
+// A separate geographic factory leaves the original illustration fit intact.
+// Reuses its construction vocabulary: inset panes, raised mullions, six-floor
+// bands, projecting crown fins, and a louvered rooftop mechanical screen.
+export function createHeritageGeographicBuilding(record, projectPlan, offset) {
+    const h = heritageGeographicLevels;
+    const kit = createBuilder(record.name, record.id);
+    // Match the original artwork's neutral palette, using the same toon-lighting
+    // compensation as heritage-at-millennium-park.js for glass, trim and precast.
+    const shell = kit.batch("Heritage · tower and lower wing", kit.material(0x363636));
+    const base = kit.batch("Heritage · mapped ground footprint", kit.material(0x787878));
+    const stone = kit.batch("Heritage · limestone frame", kit.material(0x8c8c8c));
+    const trim = kit.batch("Heritage · bronze mullions and slab edges", kit.material(0x141414));
+    const roof = kit.batch("Heritage · roof terraces", kit.material(0x363636));
+    const mechanical = kit.batch("Heritage · mechanical penthouses", kit.material(0xa4a4a4));
+    const glass = [0x444444, 0x474747, 0x4a4a4a, 0x3a3a3a, 0x7a7a7a].map((color, i) => kit.batch(`Heritage · glazing ${i + 1}`, kit.material(color)));
+    const masonry = [0x8c8c8c, 0x787878, 0x919191, 0x808080].map((color, i) => kit.batch(`Heritage · Wabash facade ${i + 1}`, kit.material(color)));
+    const pane = (floor, bay, side = 0) => {
+        const hash = (floor * 131 + bay * 37 + side * 59 + 11) % 97;
+        return glass[hash < 5 ? 4 : hash < 8 ? 3 : hash % 3];
+    };
+    const ground = projectPlan(record.footprint.coordinates);
+    const tower = projectPlan(record.parts.find((p) => p.way === 686199648).coordinates);
+    const wing = projectPlan(record.parts.find((p) => p.way === 686199649).coordinates);
+    // The lower east wall is concave in the floor plans, unlike the straight
+    // chord in OSM. Subdivide that chord inward, retaining its mapped endpoints.
+    // The 2.1 m inset is a drawing-derived estimate, not a survey measurement.
+    const eastWing = wing.findIndex((run) => run.length > 40 && run.normal(0)[0] > 0.9);
+    if (eastWing >= 0) {
+        const run = wing[eastWing], steps = 16;
+        const points = Array.from({ length: steps + 1 }, (_, i) => run.at(run.length * i / steps, -2.1 * Math.sin(Math.PI * i / steps)));
+        wing.splice(eastWing, 1, ...points.slice(1).map((p, i) => line(points[i], p)));
+    }
+    const towerPolygon = polygonOf(tower), wingPolygon = polygonOf(wing);
+    const crownBase = heritageFloorHeight(53);
+    // A full podium supports both wings. No guessed podium ratio is used.
+    kit.prism(base, ground, [0, h.podium]);
+    kit.prism(shell, tower, [h.podium, crownBase]);
+    kit.prism(shell, wing, [h.podium, h.lowerRoof - 0.65]);
+    kit.prism(roof, wing, [h.lowerRoof - 0.65, h.lowerRoof]);
+    const center = towerPolygon.reduce((sum, p) => [sum[0] + p[0] / towerPolygon.length, sum[1] + p[1] / towerPolygon.length], [0, 0]);
+    const inset = towerPolygon.map((p) => {
+        const length = Math.hypot(p[0] - center[0], p[1] - center[1]);
+        return p.map((n, i) => n + (center[i] - n) * 1.1 / length);
+    });
+    const crown = inset.map((p, i) => line(p, inset[(i + 1) % inset.length]));
+    kit.prism(shell, crown, [crownBase, h.mainRoof - 0.75]);
+    kit.prism(stone, tower, [h.mainRoof - 0.75, h.mainRoof]);
+    // Every pane and piece of trim is a closed shallow solid. Offsets separate
+    // visible surfaces from their backing wall, avoiding coincident faces.
+    const strip = (batch, run, from, to, y0, y1, back, front) => {
+        // Stop solid trim short of polygon corners. Adjacent faces can turn
+        // inward; their projecting returns must not overlap at the same elevation.
+        const clearance = Math.max(Math.abs(back), Math.abs(front)) + 0.025;
+        from = Math.max(from, clearance);
+        to = Math.min(to, run.length - clearance);
+        if (to - from < 0.03 || y1 <= y0)
+            return;
+        kit.box(batch, run.at((from + to) / 2), run.normal(0), (to - from) / 2, back, front, y0, y1);
+    };
+    const archedPane = (batch, run, s, halfWidth, bottom, top) => {
+        const spring = top - 0.6;
+        const profile = [[-halfWidth, bottom], [halfWidth, bottom], ...Array.from({ length: 13 }, (_, i) => {
+                const angle = Math.PI * i / 12;
+                return [Math.cos(angle) * halfWidth, spring + Math.sin(angle) * 0.6];
+            })];
+        const vertex = ([side, y], depth) => { const [x, z] = run.at(s + side, depth); return [x, y, z]; };
+        const n = run.normal(0), normal = [n[0], 0, n[1]];
+        for (const [depth, sign] of [[0.10, -1], [0.14, 1]]) {
+            const faceNormal = normal.map((v) => v * sign);
+            for (let i = 1; i < profile.length - 1; i += 1)
+                kit.triangle(batch, [profile[0], profile[i], profile[i + 1]].map((p) => vertex(p, depth)), [faceNormal, faceNormal, faceNormal]);
+        }
+        profile.forEach((a, i) => {
+            const b = profile[(i + 1) % profile.length], dx = b[0] - a[0], dy = b[1] - a[1], length = Math.hypot(dx, dy);
+            kit.quad(batch, [vertex(a, 0.10), vertex(b, 0.10), vertex(b, 0.14), vertex(a, 0.14)], [[n[1] * dy / length, -dx / length, -n[0] * dy / length]]);
+        });
+    };
+    const exposed = (run, y, other, top) => y >= top || !inside(other, run.at(run.length / 2, 0.12));
+    function facade(runs, firstFloor, lastFloor, ceiling, other = [], otherTop = 0) {
+        runs.forEach((run, side) => {
+            // Small polygon facets on the curved east wing each make one bay;
+            // other faces use approximately 3 m apartment/window modules.
+            const bays = Math.max(1, Math.round(run.length / 3.15));
+            const width = run.length / bays;
+            for (let floor = firstFloor; floor <= lastFloor; floor += 1) {
+                const bottom = heritageFloorHeight(floor);
+                const top = Math.min(ceiling, floor === 57 ? h.mainRoof - 0.8 : heritageFloorHeight(floor + 1));
+                if (!exposed(run, bottom, other, otherTop))
+                    continue;
+                for (let bay = 0; bay < bays; bay += 1) {
+                    const from = bay * width + 0.20, to = (bay + 1) * width - 0.20;
+                    strip(pane(floor, bay, side), run, from, to, bottom + 0.28, top - 0.24, 0.015, 0.055);
+                    strip(trim, run, (from + to) / 2 - 0.035, (from + to) / 2 + 0.035, bottom + 0.28, top - 0.24, 0.06, 0.10);
+                }
+                const major = (floor - 9) % 6 === 0;
+                strip(major ? stone : trim, run, 0.015, run.length - 0.015, bottom + 0.03, bottom + (major ? 0.42 : 0.19), 0.07, major ? 0.28 : 0.13);
+            }
+            // Split uprights at the adjacent wing's roof, so hidden partitions do
+            // not create lines across its terrace or show through its exterior.
+            const bottom = exposed(run, heritageFloorHeight(firstFloor), other, otherTop) ? heritageFloorHeight(firstFloor) : otherTop;
+            for (let i = 0; i <= bays; i += 1) {
+                const s = Math.max(0.18, Math.min(run.length - 0.18, i * width));
+                strip(stone, run, s - 0.10, s + 0.10, bottom + 0.02, ceiling - 0.02, 0.14, 0.34);
+            }
+        });
+    }
+    facade(tower, 9, 52, crownBase, wingPolygon, h.lowerRoof);
+    facade(wing, 9, 27, h.lowerRoof - 0.65, towerPolygon, h.mainRoof);
+    facade(crown, 53, 57, h.mainRoof - 0.75);
+    // Tall pale fins and open reveals around the inset upper-floor glazing.
+    tower.forEach((run) => {
+        const bays = Math.max(1, Math.round(run.length / 3.15));
+        for (let i = 0; i < bays; i += 1) {
+            const s = (i + 0.5) * run.length / bays;
+            strip(stone, run, s - 0.28, s + 0.28, crownBase - 0.01, h.mainRoof - 0.76, -1.25, 0.40);
+        }
+    });
+    // The lower wing repeats the taller crown piers over its top three floors.
+    wing.forEach((run) => {
+        if (!exposed(run, h.lowerRoof - 1, towerPolygon, h.mainRoof))
+            return;
+        strip(stone, run, 0.02, run.length - 0.02, h.lowerRoof - 0.60, h.lowerRoof - 0.03, 0.02, 0.6);
+        const count = Math.max(1, Math.round(run.length / 3.15));
+        for (let i = 0; i < count; i += 1) {
+            const s = (i + 0.5) * run.length / count;
+            strip(stone, run, s - 0.24, s + 0.24, heritageFloorHeight(25), h.lowerRoof - 0.66, 0.35, 0.59);
+        }
+    });
+    // Mechanical volumes and a north/south screen set back from the outer rim.
+    // Their plan dimensions are estimated from the elevations and contractor photo.
+    kit.prism(mechanical, rectangle(-63, -51, 59, 86), [h.mainRoof, 189.8]);
+    const screen = line([-48.5, 91], [-48.5, 56]);
+    for (let s = 0.25; s < screen.length; s += 1.35)
+        strip(stone, screen, s, s + 0.16, h.mainRoof + 0.04, h.tip, -0.18, 0.18);
+    for (let y = h.mainRoof + 0.25; y < h.tip - 0.2; y += 0.55)
+        strip(mechanical, screen, 0.15, screen.length - 0.15, y, y + 0.28, -0.14, 0.14);
+    // Balcony stacks occupy the stepped north and south returns visible in the
+    // upper-floor plan. Slabs and rails are inset along each selected return.
+    for (const run of tower.filter((r) => r.length > 4.5 && r.length < 7.5 && Math.abs(r.normal(0)[1]) > 0.9)) {
+        for (let floor = 10; floor <= 52; floor += 1) {
+            const y = heritageFloorHeight(floor);
+            if (!exposed(run, y, wingPolygon, h.lowerRoof))
+                continue;
+            strip(stone, run, 0.32, run.length - 0.32, y, y + 0.17, -0.1, 1.05);
+            strip(trim, run, 0.32, run.length - 0.32, y + 1.02, y + 1.10, 0.95, 1.03);
+            for (let s = 0.4; s < run.length - 0.3; s += 0.55)
+                strip(trim, run, s, s + 0.045, y + 0.17, y + 1.02, 0.96, 1.01);
+        }
+    }
+    // Podium: retail at grade, parking grilles, taller upper openings, and the
+    // four preserved Wabash facades. Historic bay proportions are approximated
+    // from sheet 63746, not copied from the modern tower's glass grid.
+    ground.forEach((run) => {
+        if (run.length < 2)
+            return;
+        const west = run.normal(0)[0] < -0.9;
+        const bays = Math.max(1, Math.round(run.length / (west ? 3.4 : 4.0)));
+        const width = run.length / bays;
+        for (let bay = 0; bay < bays; bay += 1) {
+            const s = (bay + 0.5) * width, historic = west && bay >= 4 && bay < bays - 4;
+            const block = Math.min(3, Math.floor((bay - 4) / Math.max(1, (bays - 8) / 4)));
+            if (historic)
+                strip(masonry[block], run, bay * width + 0.04, (bay + 1) * width - 0.04, 0.3, 24.2 + (block % 2) * 0.5, 0.02, 0.09);
+            for (let floor = 0; floor < 6; floor += 1) {
+                const y = floor === 0 ? 0.65 : 5.3 + (floor - 1) * 3.7;
+                const top = y + (floor === 0 ? 3.95 : 2.75);
+                if (historic && block !== 1 && floor > 0)
+                    archedPane(pane(floor, bay), run, s, width * 0.31, y, top);
+                else
+                    strip(pane(floor, bay), run, s - width * 0.31, s + width * 0.31, y, top, 0.10, 0.14);
+                if (historic) {
+                    strip(stone, run, s - width * 0.34, s + width * 0.34, top + 0.03, top + 0.19, 0.15, 0.26);
+                    strip(stone, run, s - width * 0.34, s + width * 0.34, y - 0.15, y - 0.02, 0.15, 0.25);
+                }
+                else if (floor > 0) {
+                    for (let y2 = y + 0.3; y2 < top; y2 += 0.38)
+                        strip(trim, run, s - width * 0.31, s + width * 0.31, y2, y2 + 0.09, 0.15, 0.20);
+                }
+            }
+            strip(glass[0], run, s - width * 0.34, s + width * 0.34, 26.1, h.podium - 0.8, 0.025, 0.055);
+            strip(stone, run, s - 0.12, s + 0.12, 25.8, h.podium - 0.7, 0.06, 0.26);
+        }
+        strip(stone, run, 0.03, run.length - 0.03, 24.9, 25.55, 0.27, 0.44);
+        strip(stone, run, 0.03, run.length - 0.03, h.podium - 0.55, h.podium - 0.03, 0.06, 0.33);
+    });
+    const model = kit.finish({ height: h.tip, outlines: [base, shell, mechanical], opacity: 0.16 });
+    model.building.position.set(offset[0], 0, offset[1]);
+    model.building.userData["geography"] = record;
+    model.building.userData["geographicDetail"] = { levels: h, highestOccupiedFloor: 57, source: "docs/heritage-geographic-reference.md" };
+    return model;
+}

package/site/models/hyatt-west-tower-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";
+// The Hyatt Regency Chicago's West Tower, 151 East Wacker Drive (A. Epstein and Sons, 1974):
+// the geographic layout's model, on its mapped part 235920252. The original layout has no
+// model of it. From the photograph's camera it stands between Aon Center and the Blue Cross
+// and Blue Shield Tower, where the drawing's Blue Cross group paints a dark brown sliver.
+//
+// A brick slab of 33 storeys: each face carries narrow window slots, continuous from the
+// lobby to the top two floors, on a 3.5 m module between solid corners, and a plain band
+// over them to a flat roof at the published 111.3 m. See docs/hyatt-west-tower-reference.md.
+// Units are meters; +x is east, +z is south.
+export const hyattWestLevels = Object.freeze({
+    floors: 33,
+    roof: 111.3, // the published height, the Skyscraper Center's 365 ft
+    band: 31, // the last floor with windows; the two above are the plain band
+    module: 3.5, // the slots' spacing, measured on the photograph and the drawing
+    slot: 1, // each slot's width
+    corner: 2, // the solid brick at least left at each corner
+});
+const h = hyattWestLevels;
+const pitch = h.roof / h.floors;
+// The skins' colours: the window tones, and the brick and the slots' spandrels, which no window
+// shares.
+export const hyattWestPalette = Object.freeze({ glass: [0x202020, 0x242424, 0x282828, 0x1d1d1d], lit: 0x6d6d6d, dim: 0x4a4a4a, brick: 0x3b3b3b, spandrel: 0x2c2c2c });
+const palette = hyattWestPalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim), brick = color(palette.brick), spandrel = color(palette.spandrel);
+const core = color(0x282828), roofing = color(0x333333);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 43, 0x9e3779b1) ^ Math.imul(bay + 19, 0x85ebca77) ^ Math.imul(wall + 7, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 10)
+        return litGlass;
+    if (value < 16)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+export const hyattWestRows = [{ lo: 0.25, hi: pitch - 0.3, kind: "glass", floor: 1 }];
+for (let n = 2; n <= h.band; n += 1) {
+    const floor = (n - 1) * pitch;
+    hyattWestRows.push({ lo: hyattWestRows.at(-1).hi, hi: floor + 0.8, kind: "spandrel", floor: n });
+    hyattWestRows.push({ lo: floor + 0.8, hi: floor + 2.9, kind: "glass", floor: n });
+}
+hyattWestRows.push({ lo: hyattWestRows.at(-1).hi, hi: h.roof, kind: "band", floor: h.band + 1 });
+const rows = hyattWestRows;
+export function createHyattWestTowerGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Hyatt Regency West Tower · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Hyatt Regency West Tower · brick and windows", kit.material(0xffffff, { vertexColors: true }));
+    const lot = orient(polygonOf(projectPlan(record.parts[0].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 skin, one box to a chain, held 2 cm clear of its ends or 9 cm where the
+    // outline turns in: slots on the module, set out from the chain's middle, as many as leave
+    // the corners solid; the lobby's glass runs the chain's length.
+    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.max(0, Math.floor((chain.length - 2 * h.corner - h.slot) / h.module) + 1);
+        const centres = Array.from({ length: count }, (_, k) => chain.length / 2 + (k - (count - 1) / 2) * h.module);
+        const cuts = centres.flatMap((c) => [c - h.slot / 2, c + h.slot / 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.07, (bay, r) => {
+            const row = rows[r], middle = (columns[bay - 1] + columns[bay]) / 2;
+            if (row.kind === "band")
+                return brick;
+            if (row.floor === 1)
+                return paneColor(row.floor, bay, index);
+            if (!centres.some((c) => Math.abs(middle - c) < h.slot / 2))
+                return brick;
+            return row.kind === "glass" ? paneColor(row.floor, bay, index) : spandrel;
+        }, brick);
+    });
+    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/hyatt-west-tower-reference.md" };
+    return model;
+}

package/site/models/keith-ascher-geographic.js

@@ -0,0 +1,110 @@
+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";
+export const keithSpec = { name: "Edson Keith Building", top: 30.78, drawnTop: 35.69, drawnWindow: [30.15, 33.17], bays: [[1.67, 5.36], [7.24, 12.09], [13.44, 17.34]], seed: 11 };
+export const ascherSpec = { name: "Theodore Ascher Building", top: 30.78, drawnTop: 35.48, drawnWindow: [29.97, 32.97], bays: [[1.85, 5.7], [7.9, 11.75]], seed: 17 };
+// Each building's levels: the ground floor's shopfronts under a sign band, and six floors
+// from the second up to the seventh, whose drawn window, scaled, sets their pitch; its sill
+// stands 80 cm over its floor.
+export function gageGroupLevels(spec) {
+    const drawn = (height) => height * spec.top / spec.drawnTop;
+    const [sill, head] = spec.drawnWindow.map(drawn);
+    const second = 5.5, seventh = sill - 0.8;
+    return Object.freeze({ shopfront: 4.3, second, pitch: (seventh - second) / 5, sill: 0.8, window: head - sill, top: spec.top });
+}
+// The skins' colours: the window tones, and the brick and the band, which no window shares.
+export const gageGroupPalette = Object.freeze({ glass: [0x262626, 0x2a2a2a, 0x2e2e2e, 0x323232], lit: 0x6e6e6e, dim: 0x3a3a3a, brick: 0x464646, band: 0x525252 });
+const palette = gageGroupPalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim);
+const brick = color(palette.brick), band = color(palette.band);
+const core = color(0x262626), roofing = color(0x3a3a3a);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 29, 0x9e3779b1) ^ Math.imul(bay + 71, 0x85ebca77) ^ Math.imul(wall + 59, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 4)
+        return litGlass;
+    if (value < 8)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+function createGageGroupBuilding(spec, record, projectPlan, offset) {
+    const h = gageGroupLevels(spec);
+    const floor = (n) => (n < 2 ? 0 : h.second + (n - 2) * h.pitch);
+    const rows = [
+        { lo: 0.25, hi: 0.9, kind: "wall", floor: 1 },
+        { lo: 0.9, hi: h.shopfront, kind: "glass", floor: 1 },
+        { lo: h.shopfront, hi: h.second, kind: "band", floor: 1 },
+    ];
+    for (let n = 2; n <= 7; n += 1) {
+        rows.push({ lo: rows.at(-1).hi, hi: floor(n) + h.sill, kind: "wall", floor: n });
+        rows.push({ lo: floor(n) + h.sill, hi: floor(n) + h.sill + h.window, kind: "glass", floor: n });
+    }
+    rows.push({ lo: rows.at(-1).hi, hi: h.top, kind: "wall", floor: 8 });
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch(`${spec.name} · shell`, kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch(`${spec.name} · brick and windows`, kit.material(0xffffff, { vertexColors: true }));
+    const lot = orient(polygonOf(projectPlan(record.footprint.coordinates)));
+    // The lot's south-east corner, where its Michigan front starts north.
+    const corner = lot.reduce((best, p) => (p[0] + p[1] > best[0] + best[1] ? p : best));
+    const northEast = lot.reduce((best, p) => (p[0] - p[1] > best[0] - best[1] ? p : best));
+    const north = [northEast[0] - corner[0], northEast[1] - corner[1]];
+    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.top, b[1]], [a[0], h.top, a[1]]], [[n[0], 0, n[1]]], core);
+    });
+    paintedSlab(kit, shell, lot, 0, false, roofing);
+    paintedSlab(kit, shell, lot, h.top, true, roofing);
+    // A wall's skin, one box to a chain the `keep` test accepts, held 2 cm clear of its ends
+    // or 9 cm where the outline turns in. `openings` lays a wall's columns out across it, from
+    // its start, and says from a cell's middle and floor whether it holds a window. Only the
+    // front carries the sign band.
+    const skin = (seed, keep, openings) => {
+        const plan = planOf(lot), heights = [rows[0].lo, ...rows.map((row) => row.hi)];
+        chainsOf(plan).forEach((chain, index) => {
+            if (!chain.runs.every((run) => keep(plan[run])))
+                return;
+            const first = chain.runs[0], last = chain.runs.at(-1);
+            const s0 = turnsAt(plan, first)[0] > 0 ? 0.09 : 0.02, s1 = chain.length - (turnsAt(plan, last)[1] > 0 ? 0.09 : 0.02);
+            const [columns, glazed] = openings(chain.length, plan[first].at(0));
+            chainSkin(kit, wall, plan, chain, 0, chain.runs.length - 1, s0, s1, columns, heights, 0.02, 0.07, (bay, r) => {
+                const row = rows[r];
+                if (row.kind === "band")
+                    return seed === 0 ? band : brick;
+                return row.kind === "glass" && glazed((columns[bay - 1] + columns[bay]) / 2, row.floor) ? paneColor(row.floor, bay, seed * 8 + index) : brick;
+            }, brick);
+        });
+    };
+    const facing = (x, z) => (run) => run.normal(0)[0] * x + run.normal(0)[1] * z > 0.9;
+    // The Michigan front, as drawn from its south corner: each bay's Chicago window, a sash
+    // 80 cm wide either side of its fixed pane, split from it by 12 cm mullions painted in the
+    // window's plane. The front's chain runs from whichever corner the outline's winding gives
+    // it.
+    const michigan = (length, start) => {
+        const fromSouth = Math.hypot(start[0] - corner[0], start[1] - corner[1]) < Math.hypot(north[0], north[1]) / 2;
+        const at = (s) => (fromSouth ? s : length - s);
+        const spans = spec.bays.map(([a, b]) => [at(a), at(b)].sort((p, q) => p - q));
+        const mullions = spans.flatMap(([a, b]) => [a + 0.8, b - 0.8]);
+        const cuts = [...spans.flat(), ...mullions.flatMap((m) => [m - 0.06, m + 0.06])].filter((s) => s > 0.1 && s < length - 0.1);
+        return [[0, ...[...new Set(cuts)].sort((p, q) => p - q), length], (middle) => spans.some(([a, b]) => middle > a && middle < b) && !mullions.some((m) => Math.abs(middle - m) < 0.06)];
+    };
+    // The alley: windows 1.6 m wide spread evenly about 3.2 m apart on every floor above the
+    // ground floor.
+    const alley = (length) => {
+        const count = Math.max(1, Math.round(length / 3.2)), centres = Array.from({ length: count }, (_, i) => length * (i + 0.5) / count);
+        return [[0, ...centres.flatMap((c) => [c - 0.8, c + 0.8]), length], (middle, floor) => floor >= 2 && centres.some((c) => Math.abs(middle - c) < 0.8)];
+    };
+    skin(0, facing(1, 0), michigan);
+    skin(1, facing(-1, 0), alley);
+    // The party walls keep the bare shell. The Gage, each other and the University Club cover
+    // them, and a skin would stand into the neighbour's lot, its top level with the other
+    // building's roof.
+    const model = kit.finish({ height: h.top, 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/keith-ascher-reference.md" };
+    return model;
+}
+export const createKeithGeographicBuilding = (record, projectPlan, offset) => createGageGroupBuilding(keithSpec, record, projectPlan, offset);
+export const createAscherGeographicBuilding = (record, projectPlan, offset) => createGageGroupBuilding(ascherSpec, record, projectPlan, offset);

package/site/models/kemper-geographic.js

@@ -0,0 +1,153 @@
+import { createBuilder, inside, line, polygonOf } from "./building-kit.js";
+// Kemper Building at 1 East Wacker Drive: the geographic layout's detailed
+// model. The mapped ground outline and tower part keep their OpenStreetMap
+// outlines; the 159 m top is OSM's height tag (522 ft in the 1962 record).
+// The marble shell, window bays, raised mullions, dark crown band with light
+// fins, and projecting cap reuse the fitted model's vocabulary at meter scale.
+// Window-row, bay, and crown spacings are estimates; see
+// docs/kemper-geographic-reference.md. Units are meters; +x is east, +z south.
+export const kemperGeographicLevels = Object.freeze({
+    podium: 7.8, // OSM way 685494067: two floors at the tower's average floor height
+    roof: 159, // OSM height tag on way 64389514
+    floors: 41,
+});
+const h = kemperGeographicLevels;
+// Floors 1-2 are the podium; the tower pitch follows the published 41 floors.
+const pitch = (h.roof - h.podium) / (h.floors - 2);
+const floorHeight = (floor) => h.podium + (floor - 3) * pitch;
+// The crown band spans the 40th and 41st floors up to the roof: dark glazing
+// behind light fins, capped by a projecting parapet.
+const crownBase = floorHeight(40);
+const shaftTop = h.roof - 0.5;
+export function createKemperGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    // The neutral gray palette of the fitted model: marble shell, dark glazing
+    // with scattered lit units, pale mullions and fins.
+    const marble = kit.batch("Kemper · marble shell", kit.material(0x929292));
+    const mullions = kit.batch("Kemper · mullions and bands", kit.material(0x9b9b9b));
+    const crownGlass = kit.batch("Kemper · crown glazing", kit.material(0x1c1c1c));
+    const crownFins = kit.batch("Kemper · crown fins", kit.material(0xa3a3a3));
+    const cap = kit.batch("Kemper · roof cap", kit.material(0xa8a8a8));
+    const lit = kit.batch("Kemper · lit glazing", kit.material(0x6a6a6a));
+    const dim = kit.batch("Kemper · dim glazing", kit.material(0x505050));
+    const tones = [0x2e2e2e, 0x323232, 0x363636, 0x2a2a2a].map((color, i) => kit.batch(`Kemper · glazing ${i + 1}`, kit.material(color)));
+    const paneTone = (row, bay, side) => {
+        const hash = (Math.imul(row + 11, 0x9e3779b1) ^ Math.imul(bay + 31, 0x85ebca77) ^ Math.imul(side + 7, 0xc2b2ae3d)) >>> 0;
+        const value = hash % 97;
+        if (value < 3)
+            return lit;
+        if (value < 6)
+            return dim;
+        return tones[value % tones.length];
+    };
+    const ground = projectPlan(record.footprint.coordinates);
+    const tower = projectPlan(record.parts.find((p) => p.way === 685494066).coordinates);
+    const towerPolygon = polygonOf(tower);
+    // The mapped volumes: the full ground outline supports the tower, and the
+    // tower part rises from the podium, so no coincident exterior walls overlap.
+    kit.prism(marble, ground, [0, h.podium]);
+    kit.prism(marble, tower, [h.podium, shaftTop]);
+    // A closed shallow solid on a run. Offsets separate the visible surfaces from
+    // their backing wall, and the ends stop short of polygon corners so adjacent
+    // walls' projecting returns cannot overlap at the same elevation.
+    const strip = (batch, run, from, to, y0, y1, back, front) => {
+        const clearance = Math.max(Math.abs(back), Math.abs(front)) + 0.025;
+        from = Math.max(from, clearance);
+        to = Math.min(to, run.length - clearance);
+        if (to - from < 0.03 || y1 <= y0)
+            return;
+        kit.box(batch, run.at((from + to) / 2), run.normal(0), (to - from) / 2, back, front, y0, y1);
+    };
+    // Tower facade: one pane per bay per row between full-height mullions, with
+    // a spandrel at each floor line. Mullions stand proudest of the tower detail.
+    tower.forEach((run, side) => {
+        const bays = Math.max(1, Math.round(run.length / 3.1));
+        const width = run.length / bays;
+        for (let floor = 3; floor <= 39; floor += 1) {
+            const bottom = floorHeight(floor), top = floorHeight(floor + 1);
+            for (let bay = 0; bay < bays; bay += 1) {
+                strip(paneTone(floor, bay, side), run, bay * width + 0.16, (bay + 1) * width - 0.16, bottom + 0.26, top - 0.24, 0.02, 0.07);
+            }
+            strip(mullions, run, 0.015, run.length - 0.015, top - 0.15, top + 0.05, 0.03, 0.12);
+        }
+        for (let i = 0; i <= bays; i += 1) {
+            const s = Math.max(0.18, Math.min(run.length - 0.18, i * width));
+            strip(mullions, run, s - 0.06, s + 0.06, h.podium + 0.02, crownBase - 0.05, 0.05, 0.16);
+        }
+        strip(mullions, run, 0.015, run.length - 0.015, h.podium - 0.05, h.podium + 0.35, 0.06, 0.18);
+    });
+    // The crown: dark glazing between light fins over the top two floors, then
+    // a projecting closed cap at the 159 m roof. The mapped outline carries
+    // sub-meter tracing jogs on its north and west edges; the prisms keep them,
+    // but a closed band cannot turn their concave corners, so the cap ring drops
+    // vertices within 1.2 m of the chord between their neighbours and verifies
+    // that every remaining corner is convex: a future part refresh could add a
+    // jog the tolerance keeps, which must fail here with a clear message rather
+    // than as a band error at page load.
+    tower.forEach((run) => {
+        strip(crownGlass, run, 0.12, run.length - 0.12, crownBase + 0.05, shaftTop - 0.25, 0.01, 0.05);
+        const count = Math.max(1, Math.round(run.length / 1.05));
+        for (let i = 0; i < count; i += 1) {
+            const s = (i + 0.5) * run.length / count;
+            strip(crownFins, run, s - 0.13, s + 0.13, crownBase - 0.05, shaftTop - 0.2, 0.04, 0.28);
+        }
+    });
+    const simplified = tower.map((run) => run.at(0));
+    for (let pass = 0; pass < 8; pass += 1) {
+        let changed = false;
+        for (let i = 0; i < simplified.length; i += 1) {
+            const a = simplified[(i - 1 + simplified.length) % simplified.length];
+            const b = simplified[(i + 1) % simplified.length];
+            const chord = Math.hypot(b[0] - a[0], b[1] - a[1]);
+            const p = simplified[i];
+            if (chord < 1e-9 || (Math.abs((b[0] - a[0]) * (a[1] - p[1]) - (a[0] - p[0]) * (b[1] - a[1])) / chord < 1.2 && simplified.length > 4)) {
+                simplified.splice(i, 1);
+                changed = true;
+                break;
+            }
+        }
+        if (!changed)
+            break;
+    }
+    for (let i = 0; i < simplified.length; i += 1) {
+        const a = simplified[(i - 1 + simplified.length) % simplified.length];
+        const b = simplified[i];
+        const c = simplified[(i + 1) % simplified.length];
+        const turn = ((b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0]))
+            / (Math.hypot(b[0] - a[0], b[1] - a[1]) * Math.hypot(c[0] - b[0], c[1] - b[1]));
+        if (turn > 1e-6)
+            throw new Error("Kemper's mapped cap ring still turns a concave corner after simplification.");
+    }
+    const capRuns = simplified.map((p, i) => line(p, simplified[(i + 1) % simplified.length]));
+    kit.band(cap, capRuns, shaftTop, h.roof, 0.4, { closed: true });
+    // Podium: storefront glazing at grade, its mullions, a spandrel head, the
+    // second floor's windows, and a projecting cap. Cap pieces under the tower
+    // are skipped so the cap does not run through the tower's walls.
+    ground.forEach((run, side) => {
+        if (run.length < 2)
+            return;
+        const bays = Math.max(1, Math.round(run.length / 3.0));
+        const width = run.length / bays;
+        for (let bay = 0; bay < bays; bay += 1) {
+            strip(paneTone(1, bay, side), run, bay * width + 0.18, (bay + 1) * width - 0.18, 0.9, 4.4, 0.02, 0.07);
+            strip(paneTone(2, bay, side + 9), run, bay * width + 0.18, (bay + 1) * width - 0.18, 5.1, 7.15, 0.02, 0.07);
+        }
+        for (let i = 0; i <= bays; i += 1) {
+            const s = Math.max(0.18, Math.min(run.length - 0.18, i * width));
+            strip(mullions, run, s - 0.06, s + 0.06, 0.85, 7.2, 0.04, 0.13);
+        }
+        strip(mullions, run, 0.015, run.length - 0.015, 4.45, 4.95, 0.03, 0.15);
+        const count = Math.max(1, Math.ceil(run.length / 1.5));
+        for (let index = 0; index < count; index += 1) {
+            const from = index * run.length / count, to = (index + 1) * run.length / count;
+            if (inside(towerPolygon, run.at((from + to) / 2, 0.3)))
+                continue;
+            strip(mullions, run, from, to, 7.35, h.podium, 0.02, 0.3);
+        }
+    });
+    const model = kit.finish({ height: h.roof, outlines: [marble, cap], opacity: 0.16 });
+    model.building.position.set(offset[0], 0, offset[1]);
+    model.building.userData["geography"] = record;
+    model.building.userData["geographicDetail"] = { levels: h, floors: 41, source: "docs/kemper-geographic-reference.md" };
+    return model;
+}

package/site/models/kemper.js

@@ -0,0 +1,78 @@
+import * as THREE from "../vendor/three-r186.js";
+// Proportions follow the existing SVG, in the Crain model's scene units.
+// This is a closed, reusable mesh; the footprint and unseen faces are inferred.
+export function createKemperBuilding() {
+    const building = new THREE.Group();
+    building.name = "Kemper Building";
+    building.userData["buildingId"] = "building-kemper";
+    const width = 31;
+    const depth = 53.5;
+    const height = 141;
+    const gradient = new THREE.DataTexture(new Uint8Array([70, 135, 200, 255]), 4, 1, THREE.RedFormat);
+    gradient.minFilter = gradient.magFilter = THREE.NearestFilter;
+    gradient.needsUpdate = true;
+    const material = (color) => new THREE.MeshToonMaterial({ color, gradientMap: gradient });
+    const stone = material(0x929292);
+    const glass = material(0x303030);
+    const ribs = material(0x9b9b9b);
+    const crown = material(0x383838);
+    const materials = [stone, glass, ribs, crown];
+    let triangleCount = 0;
+    function box(name, size, position, surface) {
+        const mesh = new THREE.Mesh(new THREE.BoxGeometry(...size), surface);
+        mesh.name = name;
+        mesh.position.set(...position);
+        mesh.castShadow = mesh.receiveShadow = true;
+        building.add(mesh);
+        triangleCount += 12;
+        return mesh;
+    }
+    const shell = box("closed tower shell", [width, height - 3, depth], [0, (height - 3) / 2, 0], stone);
+    box("recessed crown", [width + 0.1, 2.1, depth + 0.1], [0, height - 1.95, 0], crown);
+    box("roof cap", [width + 1.1, 0.9, depth + 1.1], [0, height - 0.45, 0], ribs);
+    const windowPositions = [], ribPositions = [];
+    function quad(target, a, b, c, d) {
+        for (const point of [a, b, c, a, c, d])
+            target.push(...point);
+    }
+    const corners = [[-width / 2, depth / 2], [width / 2, depth / 2], [width / 2, -depth / 2], [-width / 2, -depth / 2]];
+    for (let face = 0; face < 4; face += 1) {
+        const a = corners[face], b = corners[(face + 1) % 4];
+        const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        const normal = [(a[1] - b[1]) / length, (b[0] - a[0]) / length];
+        const point = (t, y, offset) => [a[0] + (b[0] - a[0]) * t + normal[0] * offset, y, a[1] + (b[1] - a[1]) * t + normal[1] * offset];
+        const strip = (target, left, right, bottom, top, offset) => quad(target, point(left, bottom, offset), point(right, bottom, offset), point(right, top, offset), point(left, top, offset));
+        for (let bay = 0; bay < 14; bay += 1) {
+            // The SVG's left face has a broad blank panel between these window bays.
+            if (face !== 0 || bay === 0 || bay >= 8) {
+                const left = (bay + 0.18) / 14, right = (bay + 0.73) / 14;
+                strip(windowPositions, left, right, 5, height - 3.1, 0.025);
+                // Raised mullions have front and side faces, so orbiting reveals depth.
+                const fin = 0.16 / length;
+                strip(ribPositions, left - fin, left, 5, height - 3.1, 0.27);
+                quad(ribPositions, point(left, 5, 0.025), point(left, height - 3.1, 0.025), point(left, height - 3.1, 0.27), point(left, 5, 0.27));
+                strip(ribPositions, right, right + fin, 5, height - 3.1, 0.27);
+                quad(ribPositions, point(right, 5, 0.27), point(right, height - 3.1, 0.27), point(right, height - 3.1, 0.025), point(right, 5, 0.025));
+            }
+            strip(ribPositions, (bay + 0.3) / 14, (bay + 0.38) / 14, height - 3, height - 0.9, 0.12);
+        }
+    }
+    for (const [name, positions, surface] of [["vertical window bays", windowPositions, glass], ["raised mullions and crown slots", ribPositions, ribs]]) {
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+        geometry.computeVertexNormals();
+        const mesh = new THREE.Mesh(geometry, surface);
+        mesh.name = name;
+        mesh.castShadow = mesh.receiveShadow = true;
+        building.add(mesh);
+        triangleCount += positions.length / 9;
+    }
+    const edges = new THREE.LineSegments(new THREE.EdgesGeometry(shell.geometry), new THREE.LineBasicMaterial({ color: 0xcccccc, transparent: true, opacity: 0.3 }));
+    edges.position.copy(shell.position);
+    building.add(edges);
+    return {
+        building, height, triangleCount,
+        setHighlighted(highlighted) { materials.forEach((surface) => surface.emissive.setHex(highlighted ? 0x222222 : 0)); },
+        setWireframe(enabled) { materials.forEach((surface) => { surface.wireframe = enabled; }); edges.visible = !enabled; },
+    };
+}