@a2f0/skyline 0.0.0-stage → 0.1.1

package/lib/models/buckingham-geographic.js

@@ -0,0 +1,121 @@
+import * as THREE from "../vendor/three-r186.js";
+import { createBuilder, polygonOf } from "./building-kit.js";
+import { chainSkin, chainsOf, orient, paintedSlab, planOf, turnAt, turnsAt } from "./facade-grid.js";
+// The Buckingham, 360 East Randolph Street (Fujikawa Johnson & Associates, 1982): the
+// geographic layout's model, on the mapped outline 95486940 and its rooftop part 284790189.
+// The original layout has no model of it; the drawing shows it right of 340 on the Park,
+// outside the excerpt it is fitted to.
+//
+// A concrete frame of five bays a face, a band at every floor over bronze ribbon windows. On
+// the south, east and north faces the end bays stand forward of the middle three, and two
+// corners are notched for stacked balconies. The top floor's tall openings sit under a cap
+// at the mapped 119 m, and the rooftop enclosure rises to the published 121.9 m. Floor levels
+// are measured on the drawing down from the mapped roof; see docs/buckingham-reference.md.
+// Units are meters; +x is east, +z is south.
+export const buckinghamLevels = Object.freeze({
+    lowestFloor: 18.94, // floor 7, the drawing's lowest floor line
+    pitch: 2.5456, // the drawn floor lines, 36 floors apart from floor 7's to floor 43's
+    capFoot: 117.4, // the top floor's openings' head, under the cap
+    roof: 119, // the cap's top, mapped
+    top: 121.9, // the rooftop enclosure's top, the published architectural height
+});
+const h = buckinghamLevels;
+// Each floor's level, from the second, over the lobby, to the 44th.
+const floor = (n) => h.lowestFloor + (n - 7) * h.pitch;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = [0x303030, 0x343434, 0x383838, 0x3c3c3c].map(color);
+const litGlass = color(0x6e6e6e), dimGlass = color(0x464646);
+const concrete = color(0x4c4c4c), lobby = color(0x3a3a3a), core = color(0x262626), roofing = color(0x3a3a3a), enclosure = color(0x2e2e2e);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 19, 0x9e3779b1) ^ Math.imul(bay + 43, 0x85ebca77) ^ Math.imul(wall + 31, 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: floor(2) - 0.3, kind: "lobby", floor: 1 }];
+for (let n = 2; n <= 43; n += 1) {
+    rows.push({ lo: floor(n) - 0.3, hi: floor(n) + 0.55, kind: "band", floor: n });
+    rows.push({ lo: floor(n) + 0.55, hi: floor(n + 1) - 0.3, kind: "glass", floor: n });
+}
+rows.push({ lo: floor(44) - 0.3, hi: floor(44) + 1.4, kind: "band", floor: 44 });
+rows.push({ lo: floor(44) + 1.4, hi: h.capFoot, kind: "glass", floor: 44 });
+rows.push({ lo: h.capFoot, hi: h.roof, kind: "band", floor: 45 });
+const heights = [rows[0].lo, ...rows.map((row) => row.hi)];
+export function createBuckinghamGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Buckingham · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Buckingham · frame and glass", kit.material(0xffffff, { vertexColors: true }));
+    const piers = kit.batch("Buckingham · piers", kit.material(0x565656));
+    const balconies = kit.batch("Buckingham · corner balconies", kit.material(0x5a5a5a));
+    const outline = (way) => orient(polygonOf(projectPlan(record.parts.find((part) => part.way === way).coordinates)));
+    const tower = outline(95486940), roofRoom = outline(284790189);
+    // A solid on an outline between two heights.
+    const solid = (corners, lo, hi, paint) => {
+        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]]], paint);
+        });
+        paintedSlab(kit, shell, corners, lo, false, roofing);
+        paintedSlab(kit, shell, corners, hi, true, roofing);
+    };
+    solid(tower, 0, h.roof, core);
+    solid(roofRoom, h.roof, h.top, enclosure);
+    // Every wall's skin, one box a chain, 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. A
+    // face's cells are a quarter bay wide, with its corner piers painted in its end cells.
+    const plan = planOf(tower), chains = chainsOf(plan);
+    chains.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(1, Math.round((chain.length - 1.2) / 1.6));
+        const columns = chain.length > 4 ? [0, 0.6, ...Array.from({ length: count - 1 }, (_, i) => 0.6 + (chain.length - 1.2) * (i + 1) / count), chain.length - 0.6, chain.length] : [0, chain.length];
+        chainSkin(kit, wall, plan, chain, 0, chain.runs.length - 1, s0, s1, columns, heights, 0.02, 0.07, (bay, r) => {
+            const row = rows[r], pier = chain.length > 4 && (bay <= 1 || bay >= columns.length - 1);
+            if (row.kind === "lobby")
+                return lobby;
+            if (row.kind === "band" || pier)
+                return concrete;
+            return paneColor(row.floor, bay, index);
+        }, concrete);
+        // Piers stand proud between a wall's bays, about 6.4 m wide: three across a face's
+        // set-back middle and five across the flat west face; an end bay has none.
+        const bays = Math.round(chain.length / 6.5);
+        for (let k = 1; k < bays; k += 1) {
+            const s = chain.length * k / bays, j = chain.starts.findLastIndex((start) => start <= s), run = plan[chain.runs[j]];
+            kit.box(piers, run.at(s - chain.starts[j]), run.normal(0), 0.3, 0.05, 0.25, 0.3, h.roof - 0.1);
+        }
+    });
+    // The notched corners: two short walls turning in between two faces. A balcony fills each
+    // notch on every floor to the 43rd, a slab held clear of the walls' skins under an L of
+    // railing along its open sides.
+    chains.forEach((chain, i) => {
+        const next = chains[(i + 1) % chains.length];
+        if (chain.length > 3 || next.length > 3 || turnAt(plan[chain.runs.at(-1)], plan[next.runs[0]]) <= 0)
+            return;
+        const a = plan[chain.runs[0]], b = plan[next.runs[0]];
+        const [p0, p1, p2] = [a.at(0), a.at(a.length), b.at(b.length)];
+        const [na, nb] = [a.normal(0), b.normal(0)];
+        const q = [p0[0] + p2[0] - p1[0], p0[1] + p2[1] - p1[1]];
+        const off = (p, n, d) => [p[0] + n[0] * d, p[1] + n[1] * d];
+        const a0 = off(p0, na, 0.07), b0 = off(p2, nb, 0.07), inner = off(off(p1, na, 0.07), nb, 0.07);
+        // Railing: the slab's open sides, 5 cm deep, turned in toward the notch's inner corner.
+        const inward = (from, to) => {
+            const [dx, dz] = [to[0] - from[0], to[1] - from[1]], l = Math.hypot(dx, dz), n = [-dz / l, dx / l];
+            return (inner[0] - from[0]) * n[0] + (inner[1] - from[1]) * n[1] > 0 ? n : [-n[0], -n[1]];
+        };
+        const [na0, nb0] = [inward(a0, q), inward(q, b0)];
+        const rail = [a0, q, b0, off(b0, nb0, 0.05), off(off(q, na0, 0.05), nb0, 0.05), off(a0, na0, 0.05)];
+        for (let n = 2; n <= 43; n += 1) {
+            kit.prism(balconies, planOf(orient([inner, a0, q, b0])), [floor(n) - 0.12, floor(n) + 0.12]);
+            kit.prism(balconies, planOf(orient(rail)), [floor(n) + 0.12, floor(n) + 1.0]);
+        }
+    });
+    const model = kit.finish({ height: h.top, outlines: [shell, piers], 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/buckingham-reference.md" };
+    return model;
+}

package/lib/models/building-kit.d.ts

@@ -0,0 +1,84 @@
+import * as THREE from "../vendor/three-r186.js";
+import type { WindowIllumination } from "./window-illumination.js";
+export declare const deg: number;
+export type Vec2 = [number, number];
+export type Vec3 = [number, number, number];
+export type Normal = Vec2;
+export interface Run {
+    length: number;
+    pieces(s0?: number, s1?: number): number;
+    at(s: number, offset?: number): Vec2;
+    normal(s?: number): Normal;
+}
+export type Plan = Run[];
+export declare function line(a: Vec2, b: Vec2): Run;
+export declare function arc(center: Vec2, radius: number, from: number, to: number, concave?: boolean, step?: number): Run;
+export declare function bulge(a: Vec2, b: Vec2, sagitta: number, step?: number): Run;
+export declare function rectangle(west: number, east: number, north: number, south: number): Plan;
+export declare const evenly: (length: number, count: number) => number[];
+export declare const cornerNormal: (a: Vec2, b: Vec2) => Vec2;
+export declare const station: (run: Run, s: number) => Station;
+export declare const along: ({ at, normal }: Station, offset: number, side?: number) => Vec2;
+export declare const point: ([x, z]: Vec2, y: number) => Vec3;
+export interface Station {
+    at: Vec2;
+    normal: Normal;
+}
+export declare function polygonOf(runs: Plan): Vec2[];
+export declare function inside(polygon: Vec2[], [x, z]: Vec2): boolean;
+export interface BatchData {
+    name: string;
+    surface: THREE.MeshToonMaterial;
+    positions: number[];
+    normals: number[];
+    colors: number[];
+}
+export interface Omission {
+    batch: string;
+    corners: Vec3[];
+    normal: Vec3;
+}
+export interface BandOptions {
+    omit?: string[];
+    from?: number;
+    to?: number;
+    closed?: boolean;
+    visible?: (point: Vec2, y: number) => boolean;
+}
+export interface BoxOptions {
+    omit?: string[];
+}
+export interface PrismOptions {
+    omit?: string[];
+}
+export interface FinishOptions {
+    height: number;
+    outlines?: BatchData[];
+    threshold?: number;
+    opacity?: number;
+}
+export interface BuildingModel {
+    building: THREE.Group;
+    height: number;
+    triangleCount: number;
+    illumination?: WindowIllumination;
+    setHighlighted(highlighted: boolean): void;
+    setWireframe(enabled: boolean): void;
+}
+export interface Builder {
+    building: THREE.Group;
+    material(color: number, extras?: THREE.MeshToonMaterialParameters): THREE.MeshToonMaterial;
+    batch(name: string, surface: THREE.MeshToonMaterial): BatchData;
+    triangle(target: BatchData, points: Vec3[], normals: Vec3[], color?: THREE.Color): void;
+    quad(target: BatchData, points: [Vec3, Vec3, Vec3, Vec3], normals: Vec3[], color?: THREE.Color): void;
+    panel(target: BatchData, run: Run, s0: number, s1: number, y0: number, y1: number, offset: number, color?: THREE.Color): void;
+    ledge(target: BatchData, run: Run, s0: number, s1: number, y: number, inner: number, outer: number, up: boolean): void;
+    band(target: BatchData, runs: Plan, y0: number, y1: number, proud: number, options?: BandOptions): void;
+    box(target: BatchData, at: Vec2, normal: Normal, halfWidth: number, back: number, front: number, y0: number, y1: number, options?: BoxOptions): void;
+    slab(target: BatchData, polygon: Vec2[], y: number, up: boolean): void;
+    prism(target: BatchData, runs: Plan, heights: number[], options?: PrismOptions): Vec2[];
+    finish(options: FinishOptions): BuildingModel;
+}
+export declare function createBuilder(name: string, buildingId: string, { gradient }?: {
+    gradient?: number[];
+}): Builder;

package/lib/models/building-kit.js

@@ -0,0 +1,358 @@
+import * as THREE from "../vendor/three-r186.js";
+// Shared geometry for fitted skyline models. A plan is a list of runs, straight or
+// arced, counterclockwise from above, so each run's outward normal is to its right.
+// Units are meters; +x is east (right in the skyline view) and +z is south.
+export const deg = Math.PI / 180;
+export function line(a, b) {
+    const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    const tangent = [(b[0] - a[0]) / length, (b[1] - a[1]) / length];
+    const normal = [-tangent[1], tangent[0]];
+    return {
+        length,
+        pieces: () => 1,
+        at: (s, offset = 0) => [a[0] + tangent[0] * s + normal[0] * offset, a[1] + tangent[1] * s + normal[1] * offset],
+        normal: () => normal,
+    };
+}
+// Angles measure the outward normal from +z toward +x. A concave arc keeps its
+// center outside the building, so the same angle gives the same normal. Facets stay
+// within `step`; 2.4° keeps silhouettes round without faceted toon bands.
+export function arc(center, radius, from, to, concave = false, step = 2.4 * deg) {
+    const length = radius * Math.abs(to - from);
+    const angle = (s) => from + (to - from) * s / length;
+    const side = concave ? -1 : 1;
+    return {
+        length,
+        pieces: (s0 = 0, s1 = length) => Math.max(1, Math.ceil(Math.abs(to - from) * (s1 - s0) / length / step - 1e-9)),
+        at(s, offset = 0) {
+            const a = angle(s), reach = side * radius + offset;
+            return [center[0] + Math.sin(a) * reach, center[1] + Math.cos(a) * reach];
+        },
+        normal: (s = 0) => [Math.sin(angle(s)), Math.cos(angle(s))],
+    };
+}
+// A gentle convex arc between two corners, bulging outward by its sagitta.
+export function bulge(a, b, sagitta, step) {
+    const chord = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    const radius = chord * chord / (8 * sagitta) + sagitta / 2;
+    const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+    const inward = [(b[1] - a[1]) / chord, -(b[0] - a[0]) / chord];
+    const center = [mid[0] + inward[0] * (radius - sagitta), mid[1] + inward[1] * (radius - sagitta)];
+    const angleOf = (p) => Math.atan2(p[0] - center[0], p[1] - center[1]);
+    let from = angleOf(a), to = angleOf(b);
+    if (to < from)
+        to += Math.PI * 2;
+    return arc(center, radius, from, to, false, step);
+}
+// A rectangular plan from its bounds, counterclockwise from above: the south, east, north,
+// then west faces. North is the smaller z.
+export function rectangle(west, east, north, south) {
+    const [sw, se, ne, nw] = [[west, south], [east, south], [east, north], [west, north]];
+    return [line(sw, se), line(se, ne), line(ne, nw), line(nw, sw)];
+}
+export const evenly = (length, count) => Array.from({ length: count + 1 }, (_, i) => length * i / count);
+export const cornerNormal = (a, b) => { const l = Math.hypot(a[0] + b[0], a[1] + b[1]); return [(a[0] + b[0]) / l, (a[1] + b[1]) / l]; };
+export const station = (run, s) => ({ at: run.at(s), normal: run.normal(s) });
+// A plan point offset outward along a station's normal and sideways along its run.
+export const along = ({ at, normal }, offset, side = 0) => [at[0] + normal[0] * offset + normal[1] * side, at[1] + normal[1] * offset - normal[0] * side];
+export const point = ([x, z], y) => [x, y, z];
+// The plan outline with the same facets the walls use, so roofs meet them edge to edge.
+export function polygonOf(runs) {
+    return runs.flatMap((run) => { const n = run.pieces(0, run.length); return Array.from({ length: n }, (_, i) => run.at(run.length * i / n)); });
+}
+// Twice the signed area with +z south, so a counterclockwise plan from above is negative.
+const shoelace = (polygon) => polygon.reduce((sum, [x, z], i) => { const [x2, z2] = polygon[(i + 1) % polygon.length]; return sum + x * z2 - x2 * z; }, 0);
+export function inside(polygon, [x, z]) {
+    let result = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i, i += 1) {
+        const [xi, zi] = polygon[i], [xj, zj] = polygon[j];
+        if ((zi > z) !== (zj > z) && x < (xj - xi) * (z - zi) / (zj - zi) + xi)
+            result = !result;
+    }
+    return result;
+}
+// A model under construction: toon materials, batched geometry, and the standard model
+// API once finished. Solids are closed by default. A caller may omit only faces another
+// surface covers, by name, and each omission is kept in building.userData.omitted so a
+// test can prove the cover.
+export function createBuilder(name, buildingId, { gradient = [70, 135, 200, 255] } = {}) {
+    const building = new THREE.Group();
+    building.name = name;
+    building.userData["buildingId"] = buildingId;
+    const omitted = building.userData["omitted"] = [];
+    const ramp = new THREE.DataTexture(new Uint8Array(gradient), gradient.length, 1, THREE.RedFormat);
+    ramp.minFilter = ramp.magFilter = THREE.NearestFilter;
+    ramp.needsUpdate = true;
+    const materials = [], batches = [];
+    const material = (color, extras = {}) => {
+        const surface = new THREE.MeshToonMaterial({ color, gradientMap: ramp, ...extras });
+        materials.push(surface);
+        return surface;
+    };
+    // Each batch is one draw call. Normals are analytic, so arc facets shade as a curve.
+    const batch = (batchName, surface) => {
+        const data = { name: batchName, surface, positions: [], normals: [], colors: [] };
+        batches.push(data);
+        return data;
+    };
+    const always = () => true;
+    // Runs must hand over end to start, and a loop must come back to where it began;
+    // otherwise the walls leave a gap no omission records.
+    const joins = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]) <= 1e-6;
+    function checkJoins(runs, label, loop) {
+        runs.forEach((run, index) => {
+            const next = runs[index + 1];
+            if (next && !joins(run.at(run.length), next.at(0)))
+                throw new Error(`A ${label}'s runs must join end to start.`);
+        });
+        const last = runs.at(-1);
+        if (loop && !joins(last.at(last.length), runs[0].at(0)))
+            throw new Error(`A ${label}'s runs must return to their start.`);
+    }
+    const white = new THREE.Color(1, 1, 1);
+    // Winding follows the first normal, so every helper stays outward-facing.
+    // Quads pass their vertices directly, avoiding temporary triangle and normal arrays
+    // for every face while retaining the same winding, vertex order, and attributes.
+    function appendTriangle(target, a, b, c, na, nb, nc, color = white) {
+        const ux = b[0] - a[0], uy = b[1] - a[1], uz = b[2] - a[2];
+        const vx = c[0] - a[0], vy = c[1] - a[1], vz = c[2] - a[2];
+        const facing = (uy * vz - uz * vy) * na[0] + (uz * vx - ux * vz) * na[1] + (ux * vy - uy * vx) * na[2];
+        if (facing < 0) {
+            const point = b;
+            b = c;
+            c = point;
+            const normal = nb;
+            nb = nc;
+            nc = normal;
+        }
+        target.positions.push(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
+        target.normals.push(na[0], na[1], na[2], nb[0], nb[1], nb[2], nc[0], nc[1], nc[2]);
+        target.colors.push(color.r, color.g, color.b, color.r, color.g, color.b, color.r, color.g, color.b);
+    }
+    function triangle(target, points, normals, color) {
+        appendTriangle(target, points[0], points[1], points[2], normals[0], normals[1], normals[2], color);
+    }
+    function quad(target, [a, b, c, d], normals, color) {
+        const na = normals[0], flat = normals.length === 1;
+        const nb = flat ? na : normals[1], nc = flat ? na : normals[2], nd = flat ? na : normals[3];
+        appendTriangle(target, a, b, c, na, nb, nc, color);
+        appendTriangle(target, a, c, d, na, nc, nd, color);
+    }
+    // Names a face that does not exist, so a typo cannot silently keep it.
+    const checkOmit = (omit, allowed, what) => {
+        const unknown = (omit ?? []).find((faceName) => !allowed.includes(faceName));
+        if (unknown)
+            throw new Error(`A ${what} has no "${unknown}" face; it has ${allowed.join(", ")}.`);
+    };
+    // A flat face of a solid, unless the caller omitted it as covered.
+    function face(target, corners, normal, skip) {
+        if (skip)
+            omitted.push({ batch: target.name, corners, normal });
+        else
+            quad(target, corners, [normal]);
+    }
+    // A rectangle mapped onto a plan run, split into facets that follow an arc. Panels
+    // are single surfaces for panes and trim, not solids.
+    function panel(target, run, s0, s1, y0, y1, offset, color) {
+        const n = run.pieces(s0, s1);
+        for (let i = 0; i < n; i += 1) {
+            const sa = s0 + (s1 - s0) * i / n, sb = s0 + (s1 - s0) * (i + 1) / n;
+            const [pa, pb] = [run.at(sa, offset), run.at(sb, offset)];
+            const [na, nb] = [run.normal(sa), run.normal(sb)].map(([x, z]) => [x, 0, z]);
+            quad(target, [[pa[0], y0, pa[1]], [pb[0], y0, pb[1]], [pb[0], y1, pb[1]], [pa[0], y1, pa[1]]], [na, nb, nb, na], color);
+        }
+    }
+    // A horizontal strip between two offsets from a run: a soffit or a ledge top.
+    function ledge(target, run, s0, s1, y, inner, outer, up) {
+        const n = run.pieces(s0, s1), normal = [[0, up ? 1 : -1, 0]];
+        for (let i = 0; i < n; i += 1) {
+            const sa = s0 + (s1 - s0) * i / n, sb = s0 + (s1 - s0) * (i + 1) / n;
+            quad(target, [point(run.at(sa, inner), y), point(run.at(sb, inner), y), point(run.at(sb, outer), y), point(run.at(sa, outer), y)], normal);
+        }
+    }
+    // A projecting band along consecutive runs, chamfered at convex corners. It is closed
+    // by its back, soffit, top, and start and end returns unless `omit` names them; a
+    // `closed` band, such as a parapet around a whole roof, turns its last corner onto its
+    // first run instead of ending. `visible` skips pieces buried inside another volume, and
+    // the band closes itself wherever it stops and reopens.
+    function band(target, runs, y0, y1, proud, { omit = [], from = 0, to = Infinity, closed = false, visible = always } = {}) {
+        if (closed && (from !== 0 || to !== Infinity))
+            throw new Error("A closed band wraps whole runs, so it takes no from or to.");
+        if (closed && visible !== always)
+            throw new Error("A closed band cannot also be trimmed by visible; split it into open bands.");
+        checkJoins(runs, closed ? "closed band" : "band", closed);
+        const faceNames = ["back", "soffit", "top", "start", "end"];
+        checkOmit(omit, faceNames, "band");
+        const [back, soffit, top, start, end] = faceNames.map((faceName) => !omit.includes(faceName));
+        const endFace = (run, s, sign, keep) => {
+            const [inner, outer] = [run.at(s), run.at(s, proud)], n = run.normal(s);
+            face(target, [point(inner, y0), point(outer, y0), point(outer, y1), point(inner, y1)], [n[1] * sign, 0, -n[0] * sign], !keep);
+        };
+        // Outward normals turn counterclockwise from above at a convex corner, opening a wedge to fill.
+        const cornerWedge = (run, next) => {
+            const at = run.at(run.length), n1 = run.normal(run.length), n2 = next.normal(0);
+            const turn = n1[0] * n2[1] - n1[1] * n2[0];
+            // Runs that double back share a point but face opposite ways, so no wedge can close
+            // the joint and both returns are missing: a hole no omission would record. Runs that
+            // merely continue straight face the same way and need no wedge at all.
+            if (Math.abs(turn) <= 1e-6 && n1[0] * n2[0] + n1[1] * n2[1] < 0)
+                throw new Error("A band cannot double back on itself; end the band and start another.");
+            if (turn > 1e-6)
+                throw new Error("A band cannot turn a concave corner; split it into two bands there.");
+            if (turn >= -1e-6)
+                return;
+            const a = run.at(run.length, proud), b = next.at(0, proud), mitre = cornerNormal(n1, n2);
+            quad(target, [point(a, y0), point(b, y0), point(b, y1), point(a, y1)], [[mitre[0], 0, mitre[1]]]);
+            if (soffit)
+                triangle(target, [point(at, y0), point(b, y0), point(a, y0)], [[0, -1, 0], [0, -1, 0], [0, -1, 0]]);
+            else
+                omitted.push({ batch: target.name, corners: [point(at, y0), point(b, y0), point(a, y0)], normal: [0, -1, 0] });
+            if (top)
+                triangle(target, [point(at, y1), point(a, y1), point(b, y1)], [[0, 1, 0], [0, 1, 0], [0, 1, 0]]);
+            else
+                omitted.push({ batch: target.name, corners: [point(at, y1), point(a, y1), point(b, y1)], normal: [0, 1, 0] });
+        };
+        const pieces = [];
+        runs.forEach((run, index) => {
+            const first = index === 0 ? from : 0, last = Math.min(run.length, index === runs.length - 1 ? to : Infinity);
+            if (last - first <= 1e-9)
+                return;
+            const count = run.pieces(first, last);
+            for (let i = 0; i < count; i += 1) {
+                const sa = first + (last - first) * i / count, sb = first + (last - first) * (i + 1) / count;
+                pieces.push({ run, index, sa, sb, shown: visible(run.at((sa + sb) / 2, proud + 0.2), y0) });
+            }
+        });
+        let drawn = false, opened = false, previous = null;
+        for (const piece of pieces) {
+            const { run, sa, sb, shown } = piece;
+            // A closed band opens with no return: its wrap-around corner closes it instead.
+            if (shown && !drawn && !(closed && !opened))
+                endFace(run, sa, -1, opened ? true : start);
+            if (!shown && drawn && previous)
+                endFace(previous.run, previous.sb, 1, true);
+            if (shown && drawn && previous && previous.index !== piece.index)
+                cornerWedge(previous.run, run);
+            drawn = shown;
+            previous = piece;
+            if (!shown)
+                continue;
+            opened = true;
+            panel(target, run, sa, sb, y0, y1, proud);
+            const [ia, ib, oa, ob] = [run.at(sa), run.at(sb), run.at(sa, proud), run.at(sb, proud)];
+            if (soffit)
+                ledge(target, run, sa, sb, y0, 0, proud, false);
+            else
+                omitted.push({ batch: target.name, corners: [point(ia, y0), point(ib, y0), point(ob, y0), point(oa, y0)], normal: [0, -1, 0] });
+            if (top)
+                ledge(target, run, sa, sb, y1, 0, proud, true);
+            else
+                omitted.push({ batch: target.name, corners: [point(ia, y1), point(ib, y1), point(ob, y1), point(oa, y1)], normal: [0, 1, 0] });
+            const [na, nb] = [run.normal(sa), run.normal(sb)].map(([x, z]) => [-x, 0, -z]);
+            const backCorners = [point(ib, y0), point(ia, y0), point(ia, y1), point(ib, y1)];
+            if (back)
+                quad(target, backCorners, [nb, na, na, nb]);
+            else
+                omitted.push({ batch: target.name, corners: backCorners, normal: [(na[0] + nb[0]) / 2, 0, (na[2] + nb[2]) / 2] });
+        }
+        if (drawn && closed && previous)
+            cornerWedge(previous.run, runs[0]);
+        else if (drawn && previous)
+            endFace(previous.run, previous.sb, 1, end);
+    }
+    // A box on a local frame: fins, mullions, posts, and rooftop masses. Depths run along
+    // the frame's normal from `back` to `front`.
+    function box(target, [x, z], normal, halfWidth, back, front, y0, y1, { omit = [] } = {}) {
+        const t = [normal[1], -normal[0]];
+        const p = (side, depth, y) => [x + t[0] * side + normal[0] * depth, y, z + t[1] * side + normal[1] * depth];
+        const faces = {
+            front: [[p(-halfWidth, front, y0), p(halfWidth, front, y0), p(halfWidth, front, y1), p(-halfWidth, front, y1)], [normal[0], 0, normal[1]]],
+            back: [[p(halfWidth, back, y0), p(-halfWidth, back, y0), p(-halfWidth, back, y1), p(halfWidth, back, y1)], [-normal[0], 0, -normal[1]]],
+            left: [[p(-halfWidth, back, y0), p(-halfWidth, front, y0), p(-halfWidth, front, y1), p(-halfWidth, back, y1)], [-t[0], 0, -t[1]]],
+            right: [[p(halfWidth, front, y0), p(halfWidth, back, y0), p(halfWidth, back, y1), p(halfWidth, front, y1)], [t[0], 0, t[1]]],
+            bottom: [[p(-halfWidth, back, y0), p(halfWidth, back, y0), p(halfWidth, front, y0), p(-halfWidth, front, y0)], [0, -1, 0]],
+            top: [[p(-halfWidth, back, y1), p(-halfWidth, front, y1), p(halfWidth, front, y1), p(halfWidth, back, y1)], [0, 1, 0]],
+        };
+        checkOmit(omit, Object.keys(faces), "box");
+        for (const [faceName, [corners, n]] of Object.entries(faces))
+            face(target, corners, n, omit.includes(faceName));
+    }
+    // Ear clipping for non-convex roofs and floors; the bundle omits ShapeUtils.
+    function slab(target, polygon, y, up) {
+        const area = shoelace(polygon);
+        const ring = polygon.map((_, i) => i), normal = [0, up ? 1 : -1, 0];
+        const convex = (a, b, c) => {
+            const pa = polygon[a], pb = polygon[b], pc = polygon[c];
+            return ((pb[0] - pa[0]) * (pc[1] - pa[1]) - (pb[1] - pa[1]) * (pc[0] - pa[0])) * area > 0;
+        };
+        const touches = (a, b, q) => {
+            const pa = polygon[a], pb = polygon[b];
+            return ((pb[0] - pa[0]) * (q[1] - pa[1]) - (pb[1] - pa[1]) * (q[0] - pa[0])) * area >= -1e-9;
+        };
+        const contains = (a, b, c, q) => touches(a, b, q) && touches(b, c, q) && touches(c, a, q);
+        for (let guard = 0; ring.length > 3 && guard < polygon.length * polygon.length; guard += 1) {
+            for (let i = 0; i < ring.length; i += 1) {
+                const [a, b, c] = [ring[(i + ring.length - 1) % ring.length], ring[i], ring[(i + 1) % ring.length]];
+                if (!convex(a, b, c) || ring.some((k) => k !== a && k !== b && k !== c && contains(a, b, c, polygon[k])))
+                    continue;
+                triangle(target, [point(polygon[a], y), point(polygon[b], y), point(polygon[c], y)], [normal, normal, normal]);
+                ring.splice(i, 1);
+                break;
+            }
+        }
+        if (ring.length > 3)
+            throw new Error(`A slab's polygon could not be triangulated; ${ring.length} vertices remain, so check it for repeated or crossing edges.`);
+        triangle(target, ring.map((k) => point(polygon[k], y)), [normal, normal, normal]);
+    }
+    // Walls rise through the given heights, so a seam can land on a drawn corner; a roof
+    // and a floor close the volume. Returns the plan polygon.
+    function prism(target, runs, heights, { omit = [] } = {}) {
+        checkJoins(runs, "prism", true);
+        const polygon = polygonOf(runs);
+        if (shoelace(polygon) >= 0)
+            throw new Error("A prism's plan must run counterclockwise from above, or its walls face inward.");
+        runs.forEach((run) => heights.slice(1).forEach((top, i) => panel(target, run, 0, run.length, heights[i], top, 0)));
+        checkOmit(omit, ["top", "bottom"], "prism");
+        for (const [faceName, y, up] of [["top", heights.at(-1), true], ["bottom", heights[0], false]]) {
+            if (!omit.includes(faceName))
+                slab(target, polygon, y, up);
+            else
+                omitted.push({ batch: target.name, corners: polygon.map((corner) => point(corner, y)), normal: [0, up ? 1 : -1, 0] });
+        }
+        return polygon;
+    }
+    // Batches become meshes in creation order, with silhouette lines for `outlines` only.
+    function finish({ height, outlines = [], threshold = 20, opacity = 0.3 }) {
+        const meshes = new Map(batches.map((data) => {
+            const geometry = new THREE.BufferGeometry();
+            geometry.setAttribute("position", new THREE.Float32BufferAttribute(data.positions, 3));
+            geometry.setAttribute("normal", new THREE.Float32BufferAttribute(data.normals, 3));
+            if (data.surface.vertexColors)
+                geometry.setAttribute("color", new THREE.Float32BufferAttribute(data.colors, 3));
+            const mesh = new THREE.Mesh(geometry, data.surface);
+            mesh.name = data.name;
+            mesh.castShadow = mesh.receiveShadow = true;
+            building.add(mesh);
+            return [data, mesh];
+        }));
+        const lines = outlines.flatMap((data) => [...new THREE.EdgesGeometry(meshes.get(data).geometry, threshold).getAttribute("position").array]);
+        const edgeGeometry = new THREE.BufferGeometry();
+        edgeGeometry.setAttribute("position", new THREE.Float32BufferAttribute(lines, 3));
+        const edges = new THREE.LineSegments(edgeGeometry, new THREE.LineBasicMaterial({ color: 0xcccccc, transparent: true, opacity }));
+        edges.name = "silhouette edges";
+        building.add(edges);
+        return {
+            building,
+            height,
+            triangleCount: batches.reduce((count, data) => count + data.positions.length / 9, 0),
+            setHighlighted(highlighted) {
+                materials.forEach((surface) => surface.emissive.setHex(highlighted ? 0x222222 : 0x000000));
+            },
+            setWireframe(enabled) {
+                materials.forEach((surface) => { surface.wireframe = enabled; });
+                edges.visible = !enabled;
+            },
+        };
+    }
+    return { building, material, batch, triangle, quad, panel, ledge, band, box, slab, prism, finish };
+}

package/lib/models/celebrations.d.ts

@@ -0,0 +1,39 @@
+export declare const celebrations: readonly [{
+    readonly id: "bulls";
+    readonly label: "Bulls";
+    readonly lines: readonly ["GO", "BULLS"];
+    readonly adapted: true;
+}, {
+    readonly id: "cubs";
+    readonly label: "Cubs";
+    readonly lines: readonly ["GO", "CUBS", "GO"];
+    readonly adapted: false;
+}, {
+    readonly id: "sox";
+    readonly label: "White Sox";
+    readonly lines: readonly ["SOX", "PRIDE"];
+    readonly adapted: false;
+}, {
+    readonly id: "bears";
+    readonly label: "Bears";
+    readonly lines: readonly ["BEAR", "DOWN"];
+    readonly adapted: false;
+}, {
+    readonly id: "hawks";
+    readonly label: "Blackhawks";
+    readonly lines: readonly ["HAWKS", "WIN"];
+    readonly adapted: false;
+}, {
+    readonly id: "thanks";
+    readonly label: "Thanksgiving";
+    readonly lines: readonly ["GIVE", "THANKS"];
+    readonly adapted: false;
+}];
+export type CelebrationId = typeof celebrations[number]["id"];
+export interface Celebration {
+    readonly id: CelebrationId;
+    readonly label: string;
+    readonly lines: readonly string[];
+    readonly adapted: boolean;
+}
+export declare function windowWord(word: string): string[];

package/lib/models/celebrations.js

@@ -0,0 +1,44 @@
+// Documented Chicago window displays, adapted to the modeled south facade.
+// Sources and the limits of each reconstruction: docs/celebration-lighting.md.
+// `adapted` identifies unverified wording; all window placements are reconstructed.
+export const celebrations = [
+    { id: "bulls", label: "Bulls", lines: ["GO", "BULLS"], adapted: true },
+    { id: "cubs", label: "Cubs", lines: ["GO", "CUBS", "GO"], adapted: false },
+    { id: "sox", label: "White Sox", lines: ["SOX", "PRIDE"], adapted: false },
+    { id: "bears", label: "Bears", lines: ["BEAR", "DOWN"], adapted: false },
+    { id: "hawks", label: "Blackhawks", lines: ["HAWKS", "WIN"], adapted: false },
+    { id: "thanks", label: "Thanksgiving", lines: ["GIVE", "THANKS"], adapted: false },
+];
+// Five floors per letter, with a dark window between letters. These are compact
+// reconstructions, not claims to reproduce an electrician's original shade plan.
+const letters = {
+    A: ["01110", "10001", "11111", "10001", "10001"],
+    B: ["11110", "10001", "11110", "10001", "11110"],
+    C: ["01111", "10000", "10000", "10000", "01111"],
+    D: ["11110", "10001", "10001", "10001", "11110"],
+    E: ["11111", "10000", "11110", "10000", "11111"],
+    G: ["01111", "10000", "10111", "10001", "01111"],
+    H: ["10001", "10001", "11111", "10001", "10001"],
+    I: ["11111", "00100", "00100", "00100", "11111"],
+    K: ["10001", "10010", "11100", "10010", "10001"],
+    L: ["10000", "10000", "10000", "10000", "11111"],
+    N: ["10001", "11001", "10101", "10011", "10001"],
+    O: ["01110", "10001", "10001", "10001", "01110"],
+    P: ["11110", "10001", "11110", "10000", "10000"],
+    R: ["11110", "10001", "11110", "10010", "10001"],
+    S: ["01111", "10000", "01110", "00001", "11110"],
+    T: ["11111", "00100", "00100", "00100", "00100"],
+    U: ["10001", "10001", "10001", "10001", "01110"],
+    V: ["10001", "10001", "10001", "01010", "00100"],
+    W: ["10001", "10001", "10101", "10101", "01010"],
+    X: ["10001", "01010", "00100", "01010", "10001"],
+};
+export function windowWord(word) {
+    const glyphs = [...word].map((letter) => {
+        const glyph = letters[letter];
+        if (!glyph)
+            throw new Error(`Unsupported window letter: ${letter}`);
+        return glyph;
+    });
+    return Array.from({ length: 5 }, (_, row) => glyphs.map((glyph) => glyph[row]).join("0"));
+}