@a2f0/skyline 0.0.0-stage → 0.1.2

package/lib/models/railway-exchange-geographic.js

@@ -0,0 +1,176 @@
+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 Railway Exchange Building, 224 South Michigan Avenue (Frederick P. Dinkelberg of D. H.
+// Burnham & Co., 1904): the geographic layout's model, on the mapped outline 124873931. The
+// original layout has no model of it; the drawing shows it at Michigan and Jackson, left of
+// the Borg-Warner Building.
+//
+// White terracotta fronts on Michigan and Jackson rise seventeen storeys in eleven bays of
+// paired windows, with a belt under the fourteenth floor. Round windows fill the frieze on
+// the seventeenth, under a projecting cornice and a hipped copper roof. The cornice is the
+// City's 235 ft and the roof's top the Skyscraper Center's 259 ft: each is the published
+// height nearest its drawn reading. The drawn cornice reads 73.7 m, so heights read on the
+// drawing are scaled to meet it; see docs/railway-exchange-reference.md. Units are meters;
+// +x is east, +z is south.
+const drawn = (height) => height * 71.6 / 73.7;
+export const railwayExchangeLevels = Object.freeze({
+    belt: drawn(54.6), // the belt under the fourteenth floor
+    frieze: drawn(67.4), // the frieze and its round windows
+    cornice: drawn(71.8), // the projecting cornice
+    eaves: 71.6, // the cornice's top and the roof's foot, the City's 235 ft
+    top: 78.9, // the roof's top, the Skyscraper Center's 259 ft
+});
+const h = railwayExchangeLevels;
+// The skins' colours: the window tones, and the terracotta, the belt and the plain walls,
+// which no window shares.
+export const railwayExchangePalette = Object.freeze({ glass: [0x2c2c2c, 0x303030, 0x343434, 0x383838], lit: 0x6e6e6e, dim: 0x3c3c3c, terracotta: 0x808080, band: 0x909090, plain: 0x626262 });
+const palette = railwayExchangePalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim);
+const terracotta = color(palette.terracotta), band = color(palette.band), plain = color(palette.plain);
+const core = color(0x262626), roofing = color(0x3c3c3c), copper = color(0x9c9c9c);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 71, 0x9e3779b1) ^ Math.imul(bay + 101, 0x85ebca77) ^ Math.imul(wall + 83, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 4)
+        return litGlass;
+    if (value < 8)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+const rows = [{ lo: 0.25, hi: drawn(0.6), kind: "base", floor: 1 }];
+const push = (hi, kind, floor, dy) => rows.push({ lo: rows.at(-1).hi, hi: drawn(hi), kind, floor, ...(dy === undefined ? {} : { dy }) });
+push(7.4, "shop", 1);
+const sill = (n) => (n <= 13 ? 51.53 - (13 - n) * 3.843 : 55.8 + (n - 14) * 3.85);
+for (let n = 2; n <= 16; n += 1) {
+    if (n === 14) {
+        push(54.6, "wall", 13);
+        push(55.4, "band", 13);
+    }
+    push(sill(n), "wall", n);
+    push(sill(n) + 2.6, "glass", n);
+}
+push(67.4, "wall", 16);
+push(67.8, "frieze", 17);
+for (const [lo, hi] of [[67.8, 68.3], [68.3, 68.8], [68.8, 69.3], [69.3, 69.8], [69.8, 70.3]])
+    push(hi, "oculus", 17, Math.abs((lo + hi) / 2 - 69.05));
+push(71.8, "frieze", 17);
+// Over the cornice's foot, the plain walls' last row to the eaves.
+rows.push({ lo: rows.at(-1).hi, hi: h.eaves, kind: "frieze", floor: 17 });
+export function createRailwayExchangeGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Railway Exchange Building · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Railway Exchange Building · terracotta and windows", kit.material(0xffffff, { vertexColors: true }));
+    const cornice = kit.batch("Railway Exchange Building · cornice", kit.material(0x8a8a8a));
+    const lot = orient(polygonOf(projectPlan(record.footprint.coordinates)));
+    // The lot's south-east corner, on Michigan and Jackson, with the Jackson front running
+    // west and the Michigan front north to Symphony Center.
+    const corner = lot.reduce((best, p) => (p[0] + p[1] > best[0] + best[1] ? p : best));
+    const northEast = lot.reduce((best, p) => (p[0] - p[1] > best[0] - best[1] ? p : best));
+    const southWest = lot.reduce((best, p) => (p[1] - p[0] > best[1] - best[0] ? p : best));
+    const northWest = lot.reduce((best, p) => (-p[0] - p[1] > -best[0] - best[1] ? p : best));
+    const unit = (p) => { const d = Math.hypot(p[0] - corner[0], p[1] - corner[1]); return [(p[0] - corner[0]) / d, (p[1] - corner[1]) / d]; };
+    const west = unit(southWest), north = unit(northEast);
+    const at = (a, b) => [corner[0] + west[0] * a + north[0] * b, corner[1] + west[1] * a + north[1] * b];
+    const skew = west[0] * north[1] - west[1] * north[0];
+    const inLot = (p) => {
+        const [x, z] = [p[0] - corner[0], p[1] - corner[1]];
+        return [(x * north[1] - z * north[0]) / skew, (west[0] * z - west[1] * x) / skew];
+    };
+    const [jackson, michigan] = [inLot(southWest)[0], inLot(northEast)[1]];
+    const lift = ([x, z], y) => [x, y, z];
+    // The walls to the roof's foot.
+    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.eaves, b[1]], [a[0], h.eaves, a[1]]], [[n[0], 0, n[1]]], core);
+    });
+    paintedSlab(kit, shell, lot, 0, false, roofing);
+    paintedSlab(kit, shell, lot, h.eaves, true, roofing);
+    // The roof: a closed solid on the lot's four corners, 10 cm inside the lines between them,
+    // which the Jackson wall stands up to 6.7 cm inside, so that no face lies in the walls'.
+    // It rises from a foot 10 cm inside the block, up the eaves, to a flat top 10 m in from
+    // each side over the light well, as the photograph shows; the drawing simplifies it to a
+    // pyramid. Its slopes are in two triangles each, since the lot is out of square.
+    const northWestIn = inLot(northWest);
+    const ring = (inset) => orient([at(inset, inset), at(jackson - inset, inset), at(northWestIn[0] - inset, northWestIn[1] - inset), at(inset, michigan - inset)]);
+    const [eaves, crown] = [ring(0.1), ring(10)], foot = h.eaves - 0.1;
+    planOf(eaves).forEach((run) => {
+        const p = run.at(0), q = run.at(run.length), n = run.normal(0);
+        kit.quad(shell, [lift(p, foot), lift(q, foot), lift(q, h.eaves), lift(p, h.eaves)], [[n[0], 0, n[1]]], copper);
+    });
+    paintedSlab(kit, shell, eaves, foot, false, roofing);
+    paintedSlab(kit, shell, crown, h.top, true, copper);
+    // Each slope's outward normal, from its points and the roof's middle.
+    const middle = lift(at(jackson / 2, michigan / 2), (h.eaves + h.top) / 2);
+    const face = (points) => {
+        const [a, b, c] = points;
+        const n = new THREE.Vector3(b[0] - a[0], b[1] - a[1], b[2] - a[2]).cross(new THREE.Vector3(c[0] - a[0], c[1] - a[1], c[2] - a[2])).normalize();
+        const mid = [0, 1, 2].map((k) => (a[k] + b[k] + c[k]) / 3);
+        if (n.x * (mid[0] - middle[0]) + n.y * (mid[1] - middle[1]) + n.z * (mid[2] - middle[2]) < 0)
+            n.negate();
+        const normal = [n.x, n.y, n.z];
+        kit.triangle(shell, points, [normal, normal, normal], copper);
+    };
+    eaves.forEach((p, i) => {
+        const q = eaves[(i + 1) % 4], [r, s] = [crown[i], crown[(i + 1) % 4]];
+        face([lift(p, h.eaves), lift(q, h.eaves), lift(s, h.top)]);
+        face([lift(p, h.eaves), lift(s, h.top), lift(r, h.top)]);
+    });
+    // The cornice projects 90 cm along both fronts, from 12 cm inside the lines between their
+    // corners to 2 cm over the eaves, stopping 3 cm short of the north and alley walls.
+    kit.prism(cornice, planOf(orient([at(-0.9, michigan - 0.03), at(-0.9, -0.9), at(jackson - 0.03, -0.9), at(jackson - 0.03, 0.12), at(0.12, 0.12), at(0.12, michigan - 0.03)])), [h.cornice, h.eaves + 0.02]);
+    const paints = { wall: terracotta, band, plain };
+    const skin = (keep, span, seed, openings, sides) => {
+        const plan = planOf(lot), heights = [span[0].lo, ...span.map((row) => row.hi)];
+        chainsOf(plan).forEach((chain, index) => {
+            if (!chain.runs.every((run) => keep(plan[run])))
+                return;
+            const first = chain.runs[0], last = chain.runs.at(-1);
+            const s0 = turnsAt(plan, first)[0] > 0 ? 0.09 : 0.02, s1 = chain.length - (turnsAt(plan, last)[1] > 0 ? 0.09 : 0.02);
+            const [columns, cell] = openings(chain.length);
+            chainSkin(kit, wall, plan, chain, 0, chain.runs.length - 1, s0, s1, columns, heights, 0.02, 0.07, (bay, r) => {
+                const row = span[r], shows = cell((columns[bay - 1] + columns[bay]) / 2, row);
+                return shows === "glass" ? paneColor(row.floor, bay, seed * 8 + index) : paints[shows];
+            }, sides);
+        });
+    };
+    const near = (list, x) => Math.min(...list.map((c) => Math.abs(x - c)));
+    // A street front: eleven bays 4.4 m apart about its middle, each a pair of windows 1.44 m
+    // wide either side of a 47 cm mullion and a round window 2.6 m across over it, as drawn.
+    const front = (length) => {
+        const centres = Array.from({ length: 11 }, (_, k) => length / 2 + (k - 5) * 4.4);
+        const cuts = centres.flatMap((c) => [-1.675, -1.3, -0.9, -0.6, -0.235, 0.235, 0.6, 0.9, 1.3, 1.675].map((d) => c + d));
+        return [[0, ...cuts, length], (mid, row) => {
+                const dx = near(centres, mid);
+                if (row.kind === "band")
+                    return "band";
+                if (row.kind === "shop")
+                    return dx < 1.675 ? "glass" : "wall";
+                if (row.kind === "glass")
+                    return dx > 0.235 && dx < 1.675 ? "glass" : "wall";
+                if (row.kind === "oculus")
+                    return dx * dx + row.dy * row.dy <= 1.3 * 1.3 ? "glass" : "wall";
+                return "wall";
+            }];
+    };
+    // The alley's windows, which the drawing does not show: 1.6 m wide, spread evenly about
+    // 3.2 m apart, one to each floor above the ground floor, the seventeenth's as tall as the
+    // round windows' band.
+    const alley = (length) => {
+        const count = Math.max(1, Math.round(length / 3.2)), centres = Array.from({ length: count }, (_, k) => length * (k + 0.5) / count);
+        return [[0, ...centres.flatMap((c) => [c - 0.8, c + 0.8]), length], (mid, row) => ((row.kind === "glass" || row.kind === "oculus") && near(centres, mid) < 0.8 ? "glass" : "plain")];
+    };
+    const facing = (x, z) => (run) => run.normal(0)[0] * x + run.normal(0)[1] * z > 0.9;
+    // Michigan and Jackson carry the fronts; the alley has windows; the north wall, shared
+    // with Symphony Center, stays plain.
+    skin((run) => facing(1, 0)(run) || facing(0, 1)(run), rows.slice(0, -1), 0, front, terracotta);
+    skin(facing(-1, 0), rows, 1, alley, plain);
+    skin(facing(0, -1), rows, 2, (length) => [[0, length], () => "plain"], plain);
+    const model = kit.finish({ height: h.top, outlines: [shell, cornice], 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/railway-exchange-reference.md" };
+    return model;
+}

package/lib/models/river-plaza-geographic.d.ts

@@ -0,0 +1,16 @@
+import type { BuildingModel, Plan } from "./building-kit.js";
+import type { GeoBuilding } from "./skyline-geography-data.js";
+export declare const riverPlazaLevels: Readonly<{
+    podium: 8;
+    floors: 56;
+    roof: 156;
+    box: 159.7;
+    bay: 1.6;
+}>;
+export declare const riverPlazaPalette: Readonly<{
+    glass: number[];
+    lit: 9079434;
+    dim: 5263440;
+    concrete: 10132122;
+}>;
+export declare function createRiverPlazaGeographicBuilding(record: GeoBuilding, projectPlan: (coordinates: [number, number][]) => Plan, offset: [number, number]): BuildingModel;

package/lib/models/river-plaza-geographic.js

@@ -0,0 +1,104 @@
+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";
+// River Plaza, 405 North Wabash Avenue (Ezra Gordon–Jack M. Levin and Associates, 1977): the
+// geographic layout's model, on the mapped outline 285867424 and its parts. The original
+// layout has no model of it. From the photograph's camera its top stands behind Two Illinois
+// Center, in the gap between Two Prudential Plaza and Aon Center that the drawing's
+// `office-west-of-aon` group paints, the only mapped building on that sightline tall enough
+// to reach the drawn top.
+//
+// A white concrete slab of 56 storeys with notched corners: a grid of exposed frame and
+// punched windows over a low podium on the river side, to a flat roof at OpenStreetMap's 156 m
+// under a box to the published 159.7 m. See docs/river-plaza-two-illinois-center-reference.md. Units are
+// meters; +x is east, +z is south.
+export const riverPlazaLevels = Object.freeze({
+    podium: 8, // the podium's roof, OpenStreetMap's
+    floors: 56,
+    roof: 156, // the slab's roof, OpenStreetMap's
+    box: 159.7, // the rooftop box's top, the published height and tip, the Skyscraper Center's 524 ft
+    bay: 1.6, // the frame's bays, an estimate from photographs
+});
+const h = riverPlazaLevels;
+const pitch = h.roof / h.floors;
+// The skins' colours: the window tones, and the concrete, which no window shares.
+export const riverPlazaPalette = Object.freeze({ glass: [0x2c2c2c, 0x303030, 0x343434, 0x282828], lit: 0x8a8a8a, dim: 0x505050, concrete: 0x9a9a9a });
+const palette = riverPlazaPalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim), concrete = color(palette.concrete);
+const core = color(0x6a6a6a), roofing = color(0x8a8a8a);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 19, 0x9e3779b1) ^ Math.imul(bay + 37, 0x85ebca77) ^ Math.imul(wall + 29, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 12)
+        return litGlass;
+    if (value < 18)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+export function createRiverPlazaGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("River Plaza · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("River Plaza · concrete and windows", kit.material(0xffffff, { vertexColors: true }));
+    const box = kit.batch("River Plaza · rooftop box", kit.material(0x9a9a9a));
+    const [tower, podium, top] = record.parts.map((part) => orient(polygonOf(projectPlan(part.coordinates))));
+    // The slab and the podium, each a closed shell on its mapped part.
+    for (const [plan, height] of [[tower, h.roof], [podium, h.podium]]) {
+        planOf(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], height, b[1]], [a[0], height, a[1]]], [[n[0], 0, n[1]]], core);
+        });
+        paintedSlab(kit, shell, plan, 0, false, roofing);
+        paintedSlab(kit, shell, plan, height, true, roofing);
+    }
+    // The box on the roof, on its mapped part.
+    kit.prism(box, planOf(top), [h.roof, h.box]);
+    // The slab's skin, one box to a run of a chain, held 2 cm clear of the chain's ends or 9 cm
+    // where the outline turns in: on each floor, a window 1.1 m wide and 1.5 m tall in each
+    // 1.6 m bay of the frame, from the chain's middle out. A run the podium stands against, its
+    // two ends on the podium's outline, starts over the podium's roof; a chain whose runs differ
+    // is skinned in parts, which meet at their joint.
+    const plan = planOf(tower);
+    const edges = planOf(podium);
+    const onEdge = (p) => edges.some((edge) => {
+        const a = edge.at(0), b = edge.at(edge.length), t = Math.max(0, Math.min(1, ((p[0] - a[0]) * (b[0] - a[0]) + (p[1] - a[1]) * (b[1] - a[1])) / (edge.length * edge.length)));
+        return Math.hypot(p[0] - a[0] - t * (b[0] - a[0]), p[1] - a[1] - t * (b[1] - a[1])) < 0.05;
+    });
+    const covered = (run) => onEdge(run.at(0)) && onEdge(run.at(run.length));
+    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.bay);
+        const centres = Array.from({ length: 2 * count }, (_, k) => chain.length / 2 + (k - count + 0.5) * h.bay);
+        // The chain's parts, each a span of runs the podium covers alike.
+        const parts = [];
+        chain.runs.forEach((run, k) => { const part = parts.at(-1); if (part && covered(plan[run]) === covered(plan[chain.runs[part[0]]]))
+            part[1] = k;
+        else
+            parts.push([k, k]); });
+        for (const [k0, k1] of parts) {
+            const base = covered(plan[chain.runs[k0]]) ? h.podium : 0.25;
+            const from = k0 === 0 ? s0 : chain.starts[k0], to = k1 === chain.runs.length - 1 ? s1 : chain.starts[k1] + plan[chain.runs[k1]].length;
+            const heights = [base];
+            for (let n = Math.ceil(base / pitch); n < h.floors; n += 1) {
+                const sill = n * pitch + 0.75;
+                if (sill > base + 0.2)
+                    heights.push(sill, sill + 1.5);
+            }
+            heights.push(h.roof);
+            const cuts = centres.flatMap((c) => [c - 0.55, c + 0.55]).filter((s) => s > from + 0.01 && s < to - 0.01);
+            const columns = [from, ...cuts, to];
+            chainSkin(kit, wall, plan, chain, k0, k1, from, to, columns, heights, 0.02, 0.07, (bay, r) => {
+                const middle = (columns[bay - 1] + columns[bay]) / 2;
+                const glazed = r % 2 === 1 && centres.some((c) => Math.abs(middle - c) < 0.55);
+                return glazed ? paneColor(r, bay, index) : concrete;
+            }, concrete);
+        }
+    });
+    const model = kit.finish({ height: h.box, outlines: [shell, box], 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/sheraton-grand-geographic.d.ts

@@ -0,0 +1,24 @@
+import type { BuildingModel, Plan, Vec2 } from "./building-kit.js";
+import type { GeoBuilding } from "./skyline-geography-data.js";
+export declare const sheratonLevels: Readonly<{
+    pitch: 2.67;
+    topFloor: 97;
+    corner: 100.1;
+    arms: number;
+    drum: 12.2;
+    top: 112.3;
+}>;
+export declare const sheratonDrums: readonly {
+    centre: Vec2;
+    radius: number;
+    base: number;
+}[];
+export declare const sheratonPalette: Readonly<{
+    glass: number[];
+    lit: 9079434;
+    dim: 5263440;
+    precast: 8684676;
+    drum: 11842740;
+    fin: 5921370;
+}>;
+export declare function createSheratonGrandGeographicBuilding(record: GeoBuilding, projectPlan: (coordinates: [number, number][]) => Plan, offset: [number, number]): BuildingModel;

package/lib/models/sheraton-grand-geographic.js

@@ -0,0 +1,112 @@
+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 Sheraton Grand Chicago Riverwalk, 301 East North Water Street (Solomon Cordwell Buenz,
+// 1992): the geographic layout's model, on the mapped tower 592122464 and its corner part
+// 1269924307. The original layout has no model of it. The drawing's `buckingham-east` group,
+// right of The Buckingham, is its corner: a lit crown over a tower of windows.
+//
+// A cream precast tower on an L, its arms ending in round towers, of punched windows at the
+// published 2.67 m floor-to-floor. The corner's round tower rises two floors over the arms,
+// and each round end carries an open drum of maroon fins, floodlit at night. Heights stand on
+// the Skyscraper Center's datum, its top floor at 97 m and the corner drum's top at 112.3 m;
+// its 112.8 m tip, 50 cm higher, is not modelled. See docs/sheraton-grand-reference.md.
+// Units are meters; +x is east, +z is south.
+export const sheratonLevels = Object.freeze({
+    pitch: 2.67, // Emporis's floor-to-floor, 8.75 ft
+    topFloor: 97, // the Skyscraper Center's occupied height, the corner's top floor
+    corner: 100.1, // the corner's roof, a floor-to-roof of 3.1 m over it as Emporis gives it
+    arms: 100.1 - 2 * 2.67, // the arms' roof, two floors lower, at the mapped arms' 32 levels
+    drum: 12.2, // the drums' height, Emporis's architectural height over its main roof
+    top: 112.3, // the corner drum's top, the Skyscraper Center's architectural height
+});
+const h = sheratonLevels;
+// The round ends the drums stand on, circles fitted to the mapped parts' arcs within 11 cm:
+// the corner, part 1269924307, and the east and north arms' ends, parts 1269924306 and
+// 1269924308. Centres are east and north metres from Crain's centre.
+export const sheratonDrums = Object.freeze([
+    { centre: [407.44, 465.95], radius: 7.97, base: h.corner },
+    { centre: [439.52, 462.06], radius: 7.37, base: h.arms },
+    { centre: [409.75, 498.32], radius: 7.39, base: h.arms },
+]);
+// The skins' colours: the window tones, the precast, and the drums' cream and maroon fins,
+// which no window shares.
+export const sheratonPalette = Object.freeze({ glass: [0x2a2a2a, 0x2e2e2e, 0x323232, 0x262626], lit: 0x8a8a8a, dim: 0x505050, precast: 0x848484, drum: 0xb4b4b4, fin: 0x5a5a5a });
+const palette = sheratonPalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim), precast = color(palette.precast), drumFace = color(palette.drum), fin = color(palette.fin);
+const core = color(0x585858), roofing = color(0x686868);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 17, 0x9e3779b1) ^ Math.imul(bay + 89, 0x85ebca77) ^ Math.imul(wall + 37, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 14)
+        return litGlass;
+    if (value < 20)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+// A wall's rows from `base` to `top`: a window 1.5 m tall 80 cm over each floor line, the
+// floors counted down from the top floor at the published pitch, from the last floor line
+// under the base, whose window may clear it.
+function rowsFor(base, top) {
+    const heights = [base];
+    for (let level = h.topFloor - Math.ceil((h.topFloor - base) / h.pitch) * h.pitch; level < top; level += h.pitch) {
+        if (level + 0.8 > base + 0.2 && level + 2.3 < top - 0.2)
+            heights.push(level + 0.8, level + 2.3);
+    }
+    heights.push(top);
+    return heights;
+}
+export function createSheratonGrandGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Sheraton Grand · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Sheraton Grand · precast and windows", kit.material(0xffffff, { vertexColors: true }));
+    const drums = kit.batch("Sheraton Grand · drums", kit.material(0xffffff, { vertexColors: true }));
+    const tower = orient(polygonOf(projectPlan(record.parts[0].coordinates)));
+    const circle = (centre, radius, sides = 24) => orient(Array.from({ length: sides }, (_, k) => {
+        const angle = (k / sides) * Math.PI * 2;
+        return [centre[0] + radius * Math.cos(angle), -centre[1] + radius * Math.sin(angle)];
+    }));
+    const cornerPlan = orient(polygonOf(projectPlan(record.parts[1].coordinates)));
+    // A closed solid of walls and slabs on an outline, painted by its runs.
+    const solid = (target, outline, lo, hi, paint) => {
+        planOf(outline).forEach((run, k) => {
+            const a = run.at(0), b = run.at(run.length), n = run.normal(0);
+            kit.quad(target, [[a[0], lo, a[1]], [b[0], lo, b[1]], [b[0], hi, b[1]], [a[0], hi, a[1]]], [[n[0], 0, n[1]]], paint(k));
+        });
+        paintedSlab(kit, target, outline, lo, false, roofing);
+        paintedSlab(kit, target, outline, hi, true, roofing);
+    };
+    // The tower to the arms' roof, and the corner's round tower, on its mapped part, two floors
+    // over it.
+    solid(shell, tower, 0, h.arms, () => core);
+    solid(shell, cornerPlan, h.arms, h.corner, () => core);
+    // Each drum: cream, a maroon fin every other facet, on its round end.
+    for (const { centre, radius, base } of sheratonDrums)
+        solid(drums, circle(centre, radius), base, base + h.drum, (k) => (k % 2 ? fin : drumFace));
+    // The skins, one box to a chain of runs turning less than 30°, so the round ends carry one:
+    // a window 1.4 m wide in each 2.4 m bay, set out from the chain's middle, on every floor.
+    const skin = (outline, base, top, seed) => {
+        const plan = planOf(outline), heights = rowsFor(base, top);
+        chainsOf(plan, 30 * Math.PI / 180).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 - 1.4) / 2 / 2.4);
+            const centres = Array.from({ length: 2 * count + 1 }, (_, k) => chain.length / 2 + (k - count) * 2.4);
+            const cuts = centres.flatMap((c) => [c - 0.7, c + 0.7]).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 middle = (columns[bay - 1] + columns[bay]) / 2;
+                return r % 2 === 1 && centres.some((c) => Math.abs(middle - c) < 0.7) ? paneColor(r, bay, seed * 16 + index) : precast;
+            }, precast);
+        });
+    };
+    skin(tower, 0.25, h.arms, 0);
+    skin(cornerPlan, h.arms, h.corner, 1);
+    const model = kit.finish({ height: h.top, outlines: [shell, drums], 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/sheraton-grand-reference.md" };
+    return model;
+}

package/lib/models/six-north-michigan-geographic.d.ts

@@ -0,0 +1,16 @@
+import type { BuildingModel, Plan } from "./building-kit.js";
+import type { GeoBuilding } from "./skyline-geography-data.js";
+export declare const sixNorthLevels: Readonly<{
+    block: 62.1;
+    cornice: 63.6;
+    band: 65;
+    bandTop: 66.9;
+    arches: 75.6;
+    towerCornice: 78;
+    stage: 84.5;
+    top: 86;
+    towerSouth: 7.5;
+    towerNorth: 20;
+    towerDepth: 12;
+}>;
+export declare function createSixNorthMichiganGeographicBuilding(record: GeoBuilding, projectPlan: (coordinates: [number, number][]) => Plan, offset: [number, number]): BuildingModel;

package/lib/models/six-north-michigan-geographic.js

@@ -0,0 +1,180 @@
+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";
+// Six North Michigan, the Montgomery Ward Building (Schmidt, Garden & Martin, 1899; four
+// floors added by Holabird & Roche, 1923): the geographic layout's model, on the mapped
+// outline 126982631. The original layout has no model of it; the drawing shows it right of
+// Willoughby Tower, outside the excerpt it is fitted to.
+//
+// A sixteen-storey block, 27.5 m on Michigan by 49.6 m on Madison, under a projecting
+// cornice. The tower, built in the middle of the Michigan front rather than on the corner
+// first planned, rises flush with it: a floor above the block, a band, an arched stage of
+// three tall windows to a face under a cornice, and a top stage of panels under a cap at
+// 86 m, where the pyramid and statue came off in 1947. Heights are measured on the drawing
+// down from that top; see docs/six-north-michigan-reference.md. Units are meters; +x is
+// east, +z is south.
+export const sixNorthLevels = Object.freeze({
+    block: 62.1, // the block's walls, under its cornice
+    cornice: 63.6, // the block's cornice and roof
+    band: 65, // the tower's band, over the floor above the block
+    bandTop: 66.9,
+    arches: 75.6, // the arched stage, under the tower's cornice
+    towerCornice: 78, // the tower's cornice, under the top stage
+    stage: 84.5, // the top stage, under its cap
+    top: 86, // the cap, the published height
+    towerSouth: 7.5, // the tower's south wall, north of Madison
+    towerNorth: 20, // its north wall
+    towerDepth: 12, // west of the Michigan front
+});
+const h = sixNorthLevels;
+// Each floor's level: a 6 m ground floor, then 3.74 m floors to the block's cornice.
+const floor = (n) => (n < 2 ? 0 : 6 + (n - 2) * 3.74);
+const color = (hex) => new THREE.Color(hex);
+const glassTones = [0x4c4c4c, 0x505050, 0x545454, 0x585858].map(color);
+const litGlass = color(0x8a8a8a), dimGlass = color(0x5e5e5e);
+const brick = color(0x6e6e6e), panel = color(0x9c9c9c), core = color(0x2e2e2e), roofing = color(0x484848);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 31, 0x9e3779b1) ^ Math.imul(bay + 57, 0x85ebca77) ^ Math.imul(wall + 43, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 4)
+        return litGlass;
+    if (value < 8)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+const blockRows = [
+    { lo: 0.25, hi: 1, kind: "brick", floor: 1 },
+    { lo: 1, hi: 5.2, kind: "glass", floor: 1 },
+    { lo: 5.2, hi: floor(2) - 0.35, kind: "brick", floor: 1 },
+];
+for (let n = 2; n <= 16; n += 1) {
+    blockRows.push({ lo: floor(n) - 0.35, hi: floor(n) + 1.25, kind: "brick", floor: n });
+    blockRows.push({ lo: floor(n) + 1.25, hi: floor(n + 1) - 0.35, kind: "glass", floor: n });
+}
+blockRows.push({ lo: floor(17) - 0.35, hi: h.block, kind: "brick", floor: 17 });
+// The tower's rows over the block: the seventeenth floor's windows under the band; then the
+// arched stage's small windows over the band and its tall windows, their heads narrowing
+// for the last half-metre; then the top stage's panel.
+const towerRows = [
+    { lo: h.block, hi: 62.95, kind: "brick", floor: 17 },
+    { lo: 62.95, hi: 64.77, kind: "floor17", floor: 17 },
+    { lo: 64.77, hi: h.band, kind: "brick", floor: 17 },
+    { lo: h.bandTop, hi: 68.2, kind: "small", floor: 18 },
+    { lo: 68.2, hi: 70.7, kind: "brick", floor: 18 },
+    { lo: 70.7, hi: 73.7, kind: "arch", floor: 19 },
+    { lo: 73.7, hi: 74.2, kind: "head", floor: 19 },
+    { lo: 74.2, hi: h.arches, kind: "brick", floor: 20 },
+    { lo: h.towerCornice, hi: 83.2, kind: "panel", floor: 21 },
+    { lo: 83.2, hi: h.stage, kind: "brick", floor: 21 },
+];
+const rowsBetween = (rows, lo, hi) => rows
+    .map((row) => ({ ...row, lo: Math.max(row.lo, lo), hi: Math.min(row.hi, hi) }))
+    .filter((row) => row.hi - row.lo > 0.05);
+export function createSixNorthMichiganGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Six North Michigan · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Six North Michigan · brick and windows", kit.material(0xffffff, { vertexColors: true }));
+    const cornices = kit.batch("Six North Michigan · cornices", kit.material(0x747474));
+    const lot = orient(polygonOf(projectPlan(record.footprint.coordinates)));
+    // The lot's south-east corner, and its Madison and Michigan fronts running from it.
+    const corner = lot.reduce((best, p) => (p[0] + p[1] > best[0] + best[1] ? p : best));
+    const neighbours = [lot[(lot.indexOf(corner) + 1) % lot.length], lot[(lot.indexOf(corner) + lot.length - 1) % lot.length]];
+    const unit = (p) => { const d = Math.hypot(p[0] - corner[0], p[1] - corner[1]); return [(p[0] - corner[0]) / d, (p[1] - corner[1]) / d]; };
+    const [west, north] = neighbours[0][0] < neighbours[1][0] ? [unit(neighbours[0]), unit(neighbours[1])] : [unit(neighbours[1]), unit(neighbours[0])];
+    const at = (a, b) => [corner[0] + west[0] * a + north[0] * b, corner[1] + west[1] * a + north[1] * b];
+    // The inverse of `at`: a point's distances along Madison and Michigan, whose fronts meet
+    // a little off square.
+    const skew = west[0] * north[1] - west[1] * north[0];
+    const inLot = (p) => {
+        const [x, z] = [p[0] - corner[0], p[1] - corner[1]];
+        return [(x * north[1] - z * north[0]) / skew, (west[0] * z - west[1] * x) / skew];
+    };
+    const rect = (a0, a1, b0, b1) => orient([at(a0, b0), at(a1, b0), at(a1, b1), at(a0, b1)]);
+    const [depth, front] = [Math.max(...lot.map((p) => inLot(p)[0])), Math.max(...lot.map((p) => inLot(p)[1]))];
+    const tower = (grow) => rect(-grow, h.towerDepth + grow, h.towerSouth - grow, h.towerNorth + grow);
+    // A solid on an outline between two heights.
+    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(lot, 0, h.block);
+    solid(tower(0), h.block, h.arches);
+    solid(tower(-0.8), h.towerCornice, h.stage);
+    // The block's cornice overhangs its walls by a metre, stopping either side of the tower,
+    // which rises through it, 2 cm clear of its walls so that the two undersides do not share
+    // an edge; the tower's band, cornice and cap are its outline grown or shrunk.
+    const [notchNorth, notchSouth, notchBack] = [h.towerNorth + 0.02, h.towerSouth - 0.02, h.towerDepth + 0.02];
+    const corniceOutline = orient([at(-1, -1), at(depth + 1, -1), at(depth + 1, front + 1), at(-1, front + 1), at(-1, notchNorth), at(notchBack, notchNorth), at(notchBack, notchSouth), at(-1, notchSouth)]);
+    kit.prism(cornices, planOf(corniceOutline), [h.block, h.cornice]);
+    kit.prism(cornices, planOf(tower(0.5)), [h.band, h.bandTop]);
+    kit.prism(cornices, planOf(tower(1.2)), [h.arches, h.towerCornice]);
+    kit.prism(cornices, planOf(tower(-0.3)), [h.stage, h.top]);
+    // 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 to its end, and says how far each reaches into a window: 0 is brick; a
+    // floor's window takes any other; the tower's tall windows 1 and over, its seventeenth
+    // floor's 2, its small windows 3, and their heads and the top stage's panel 4. Floors
+    // below `fromFloor` stay brick.
+    const glassFrom = { brick: 99, glass: 1, floor17: 2, small: 3, arch: 1, head: 4, panel: 4 };
+    const skin = (corners, rows, lo, hi, seed, keep, openings, fromFloor = 1) => {
+        const plan = planOf(corners), cut = rowsBetween(rows, lo, hi), heights = [cut[0].lo, ...cut.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, reach] = openings(chain.length, plan[first].at(0), plan[last].at(plan[last].length));
+            chainSkin(kit, wall, plan, chain, 0, chain.runs.length - 1, s0, s1, columns, heights, 0.02, 0.07, (bay, r) => {
+                const row = cut[r], into = reach(bay);
+                if (row.kind === "panel")
+                    return into >= 4 ? panel : brick;
+                if (row.floor < fromFloor)
+                    return brick;
+                return into >= glassFrom[row.kind] ? paneColor(row.floor, bay, seed * 8 + index) : brick;
+            }, brick);
+        });
+    };
+    // Windows centred at `centres`, `width` wide, along a wall from its start.
+    const windows = (length, centres, width) => {
+        const inside = centres.filter((c) => c - width / 2 > 0.1 && c + width / 2 < length - 0.1);
+        return [[0, ...inside.flatMap((c) => [c - width / 2, c + width / 2]), length], (bay) => (bay % 2 === 0 && bay <= 2 * inside.length ? 1 : 0)];
+    };
+    // A position along a wall from its start, given in lot coordinates across it.
+    const along = (length, start, end, target, axis) => length * (target - inLot(start)[axis]) / (inLot(end)[axis] - inLot(start)[axis]);
+    const michigan = (run) => run.normal(0)[0] > 0.9, party = (run) => run.normal(0)[1] < -0.9;
+    // The Michigan front: three windows to each wing either side of the tower, and three to
+    // the tower between them, 3 m apart on the centres of the windows above.
+    const michiganFront = (length, start, end) => windows(length, [1.6, 3.75, 5.9, 10.75, 13.75, 16.75, 21.6, 23.75, 25.9].map((b) => along(length, start, end, b, 1)), 1.3);
+    // Madison, the alley and the north wall: a window every 2.75 m. The north wall is shared
+    // with 20 North Michigan, eight storeys high, and stays blank below its ninth floor.
+    const punched = (length) => { const bays = Math.round(length / 2.75); return windows(length, Array.from({ length: bays }, (_, i) => length * (i + 0.5) / bays), 1.1); };
+    skin(lot, blockRows, 0.25, h.block, 0, michigan, michiganFront);
+    skin(lot, blockRows, 0.25, h.block, 1, (run) => !michigan(run) && !party(run), punched);
+    skin(lot, blockRows, 0.25, h.block, 6, party, punched, 9);
+    // The tower's faces: three windows to a face, centred 3 m apart. A tall window is 2 m
+    // wide, its head the middle metre; the seventeenth floor's are 1.3 m and the small ones
+    // 1.1 m, all on the same centres.
+    const towerFace = (length) => {
+        const steps = [-1, -0.65, -0.55, -0.5, 0.5, 0.55, 0.65, 1];
+        const columns = [0, ...[-3, 0, 3].flatMap((d) => steps.map((s) => length / 2 + d + s)), length];
+        // Bays count from one: a pier, then 1, 2, 3, 4, 3, 2, 1 across each window.
+        return [columns, (bay) => (bay > 24 || (bay - 1) % 8 === 0 ? 0 : [0, 1, 2, 3, 4, 3, 2, 1][(bay - 1) % 8])];
+    };
+    // The top stage's panel, 7.2 m wide in the middle of each face.
+    const panelled = (length) => [[0, length / 2 - 3.6, length / 2 + 3.6, length], (bay) => (bay === 2 ? 4 : 0)];
+    // Over the block, the tower's Michigan face shows from the block's walls; the cornice
+    // hides its other faces' foot.
+    skin(tower(0), towerRows, h.block, h.band, 2, michigan, towerFace);
+    skin(tower(0), towerRows, h.cornice, h.band, 3, (run) => !michigan(run), towerFace);
+    skin(tower(0), towerRows, h.bandTop, h.arches, 4, () => true, towerFace);
+    skin(tower(-0.8), towerRows, h.towerCornice, h.stage, 5, () => true, panelled);
+    const model = kit.finish({ height: h.top, outlines: [shell, cornices], 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/six-north-michigan-reference.md" };
+    return model;
+}