@johnmorrisdotca/kyogijo-stadiums 0.46.0 → 0.48.0

package/dist/venue.real.js

@@ -6,21 +6,13 @@
 import { rayAt } from "./crowd.js";
 import { bar, box, n, pole, shy, wall } from "./turn.kit.js";
 import { pointList, raked } from "./venue.geom.js";
+import { ribbedRoof, ribbedWalls } from "./venue.ribbed.js";
+import { SADDLE_CELLS, saddleHeight, saddleRoof, saddleTowers, saddleWalls } from "./venue.saddle.js";
 import { edgeDistance, inside } from "./venues.geo.js";
-/** How far a lid rises from its edge towards the middle, and how far a saddle's high ends stand over its low sides, in feet (ours: the sources give a roof's kind, not its height). */
+/** How far a lid rises from its edge towards the middle, in feet (ours: the sources give a roof's kind, not its height). */
 export const LID_RISE = 22;
-export const SADDLE_RISE = 30;
 /** How far a barrel vault's crown stands over its springing at the long sides, in feet (ours: the article says the roof looks like a Quonset hut, not how high it rises). */
 export const BARREL_RISE = 34;
-/** The saddle's share of its rise at a point (0 at the middle of a side, 1 at the middle of an end): half a saddle's way from one to the other, as a hyperbolic paraboloid (u squared less v squared) lies over the building's box. */
-export function saddleAt(real, [x, y]) {
-    const xs = real.footprint.map((p) => p[0]);
-    const ys = real.footprint.map((p) => p[1]);
-    const [cx, cy] = [(Math.min(...xs) + Math.max(...xs)) / 2, (Math.min(...ys) + Math.max(...ys)) / 2];
-    const [hx, hy] = [(Math.max(...xs) - Math.min(...xs)) / 2, (Math.max(...ys) - Math.min(...ys)) / 2];
-    const s = ((x - cx) / hx) ** 2 - ((y - cy) / hy) ** 2;
-    return (1 + Math.max(-1, Math.min(1, s))) / 2;
-}
 /** The barrel vault's share of its rise at a point (0 at the springing along each long side, 1 over the middle line): a round arch over the building's short axis, the quarter of a circle's rise at each step in from the side. */
 export function barrelAt(real, [, y]) {
     const ys = real.footprint.map((p) => p[1]);
@@ -29,7 +21,7 @@ export function barrelAt(real, [, y]) {
     return Math.sqrt(1 - v * v);
 }
 /** The height of the roof over a point of the building's edge, above the surface, in feet. */
-export const roofAt = (real, p) => real.edge + (real.roof === "saddle" ? SADDLE_RISE * saddleAt(real, p) : real.roof === "barrel" ? BARREL_RISE * barrelAt(real, p) : 0);
+export const roofAt = (real, p) => (real.roof === "saddle" && real.saddle !== undefined ? saddleHeight(real.saddle, p) : real.edge + (real.roof === "barrel" ? BARREL_RISE * barrelAt(real, p) : 0));
 /** How near a wall must stand to a canopy's outline to be the wall under it, in feet. */
 const CANOPY_REACH = 50;
 /** The height of the wall of a building under canopies at a point of its rim: where a canopy is over it, the canopy's back edge, which the wall carries up to (the outside of Lumen Field's roofs is one curved face to the ground); elsewhere the rim's own height. */
@@ -42,17 +34,19 @@ export function wallAt(real, p) {
             top = Math.max(top, canopy.low + canopy.rise);
     return top;
 }
-/** How many rings the leaning tower's shaft is cut into, how far its foot stands wider than the shaft over it (a plinth), and the observatory's width over the shaft's top, its height and the share of it that is glass (ours). */
+/** How many rings the leaning tower's shaft is cut into, and the observatory on its top: its length along the lean, its width and its height, in feet (ours: the sources give the tower's height and its inclination, not these). */
 const TOWER_RINGS = 12;
-const TOWER_PLINTH = { wide: 1.3, high: 26 };
-const TOWER_CAP = { wide: 1.5, high: 40 };
+const TOWER_CAP = { long: 84, wide: 72, high: 34 };
+/** How far the shaft's back runs out beyond its foot, as a share of the run from the foot to the top (the back sweeps down to the ground in a long curve), how far its front stands over the top, and how far its back stands behind it, in feet (ours). */
+const TOWER_TAIL = 0.45;
+const TOWER_PRAW = { front: 18, back: 58 };
 /**
- * A tower that leans and curves: a square shaft of horizontal sections that tapers from a broad foot on the ground to a narrow top, along a curve that runs from the foot to the top (the line the map gives of its funicular), its
- * back curving up from a flatter foot to the inclination the article gives at the top; a plinth where it meets the ground, the dark slits down its sloped back, an observatory of dark and glass bands on its top and, with `cables`,
- * thin lines from the observatory to the roof. Each face of a ring is a trapezoid on a plane through its corners, so that the faces meet along their edges. The foot and the top and their height are the sources'; the curve, the
- * widths, the slits, the plinth and the observatory are ours.
+ * A tower that leans and curves: a shaft of horizontal sections, a square of rising width at its foot narrowing to its top, that leans over the building. Its foot is at the building's rim (where the mapped axis crosses it, `rim` feet
+ * from the top along the axis), its front, the steep face that looks at the building, runs from there to the top, and its back, the face that looks away and up, sweeps down from the top in a long curve that flattens to the ground
+ * far behind the foot. On the top stands the observatory, a dark block with a band of glass, and, with `cables`, thin lines run from it to the roof. Every face of a ring is a trapezoid on a plane through its corners, so the faces
+ * meet along their edges. The foot, the top and the height are the sources' (the map's funicular line and the article's inclination); the curve, the widths, the slits and the observatory are ours.
  */
-export function towerPlanes(tower, z, cables = []) {
+export function towerPlanes(tower, z, cables = [], rim) {
     const [bx, by] = tower.base;
     const [tx, ty] = tower.top;
     const run = Math.hypot(tx - bx, ty - by) || 1;
@@ -60,69 +54,70 @@ export function towerPlanes(tower, z, cables = []) {
     const a = [-d[1], d[0]];
     const [w0, w1] = tower.width;
     const H = tower.height - TOWER_CAP.high;
-    // The curve in the plane of the lean (run along the axis, height): a quadratic from the foot to the top whose tangent at the top rises at the article's inclination.
-    const lean = Math.tan((tower.angle * Math.PI) / 180);
-    const reach = Math.min(H * 0.12, run * 0.12);
-    const control = [run - reach / lean, H - reach];
-    const at = (t) => [2 * t * (1 - t) * control[0] + t * t * run, 2 * t * (1 - t) * control[1] + t * t * H];
-    const wide = (t) => w1 + (w0 - w1) * (1 - t) ** 1.15;
-    const offsets = [[-1, -1], [1, -1], [1, 1], [-1, 1]];
-    const ring = (centre, height, w, k) => [bx + d[0] * centre[0] + (a[0] * offsets[k][0] + d[0] * offsets[k][1]) * (w / 2), by + d[1] * centre[0] + (a[1] * offsets[k][0] + d[1] * offsets[k][1]) * (w / 2), z + height];
+    // Along the lean (from the foot towards the top) and across it: a point of the shaft at a place `p` along, `q` across and `h` up.
+    const at = (p, q, h) => [bx + d[0] * p + a[0] * q, by + d[1] * p + a[1] * q, z + h];
+    const front0 = Math.max(0, Math.min(run * 0.9, run - (rim ?? run * 0.5)));
+    const frontAt = (h) => front0 + (run + TOWER_PRAW.front - front0) * (h / H) ** 0.92;
+    // The back: a quadratic curve from the tail on the ground, flat there, to the top, steep there; its rings are equal steps along the curve.
+    const [p0, p1, p2] = [[-TOWER_TAIL * run, 0], [run * 0.34, H * 0.15], [run - TOWER_PRAW.back, H]];
+    const curve = (t) => [(1 - t) ** 2 * p0[0] + 2 * t * (1 - t) * p1[0] + t * t * p2[0], (1 - t) ** 2 * p0[1] + 2 * t * (1 - t) * p1[1] + t * t * p2[1]];
+    const wide = (h) => w1 + (w0 - w1) * (1 - h / H) ** 1.15;
+    const rings = Array.from({ length: TOWER_RINGS + 1 }, (_, i) => {
+        const [back, h] = curve(i / TOWER_RINGS);
+        return { h, back, front: frameFront(frontAt(h), back), w: wide(h) };
+    });
     const planes = [];
-    const face = (id, o, u, v, svg) => {
+    const face = (id, o, up, along, r, svg) => {
+        const [lu, lv] = [Math.hypot(...up), Math.hypot(...along)];
         // (A wall, not a mast: the lower tiers leave out the small parts, and a tower 165 metres high is not one.)
-        planes.push({ id, kind: "wall", o, u, v, svg });
+        planes.push({ id, kind: "wall", o, u: up, v: along, svg: `<polygon class="u-tower" points="0 0 ${n(lu)} 0 ${n(lu)} ${n(lv * r)} 0 ${n(lv)}"/>${svg(lu)}` });
     };
+    const sub = (p, q) => [p[0] - q[0], p[1] - q[1], p[2] - q[2]];
+    const scale = (p, k) => [p[0] * k, p[1] * k, p[2] * k];
     for (let i = 0; i < TOWER_RINGS; i += 1) {
-        const [t0, t1] = [i / TOWER_RINGS, (i + 1) / TOWER_RINGS];
-        const [p0, p1] = [at(t0), at(t1)];
-        const [wa, wb] = [wide(t0), wide(t1)];
-        for (let k = 0; k < 4; k += 1) {
-            const o = ring([p0[0], 0], p0[1], wa, k);
-            const up = ring([p1[0], 0], p1[1], wb, k);
-            const next = ring([p0[0], 0], p0[1], wa, (k + 1) % 4);
-            const u = [up[0] - o[0], up[1] - o[1], up[2] - o[2]];
-            const v = [next[0] - o[0], next[1] - o[1], next[2] - o[2]];
-            const [lu, lv] = [Math.hypot(...u), Math.hypot(...v)];
-            const r = wb / wa;
-            // The sloped back (the face away from the lean) has the two long dark slits down it, a few rings clear of the foot and of the top.
-            const slit = (f0, f1) => `<polygon class="u-tower-slit" points="0 ${n(f0 * lv)} ${n(lu)} ${n(f0 * lv * r)} ${n(lu)} ${n(f1 * lv * r)} 0 ${n(f1 * lv)}"/>`;
-            const slits = k === 0 && i >= 2 && i < TOWER_RINGS - 1 ? `${slit(0.24, 0.31)}${slit(0.62, 0.69)}` : "";
-            face(`tower-${i}-${k}`, o, u, v, `<polygon class="u-tower" points="0 0 ${n(lu)} 0 ${n(lu)} ${n(lv * r)} 0 ${n(lv)}"/>${slits}`);
+        const [r0, r1] = [rings[i], rings[i + 1]];
+        const wr = r1.w / r0.w;
+        const lr = (r1.front - r1.back) / (r0.front - r0.back);
+        // The front and the back: across the shaft, from the left corner of the ring to the right.
+        for (const [name, k0, k1] of [["f", "front", "front"], ["b", "back", "back"]]) {
+            const o = at(r0[k0], -r0.w / 2, r0.h);
+            const top = at(r1[k1], -r1.w / 2, r1.h);
+            // The sloped back carries the two long dark slits down it, a few rings clear of the foot and of the top.
+            const slit = (lu, f0, f1) => `<polygon class="u-tower-slit" points="0 ${n(f0 * r0.w)} ${n(lu)} ${n(f0 * r1.w)} ${n(lu)} ${n(f1 * r1.w)} 0 ${n(f1 * r0.w)}"/>`;
+            const slits = name === "b" && i >= 2 && i < TOWER_RINGS - 1 ? (lu) => `${slit(lu, 0.24, 0.31)}${slit(lu, 0.62, 0.69)}` : () => "";
+            face(`tower-${i}-${name}`, o, sub(top, o), scale([a[0], a[1], 0], r0.w), wr, slits);
         }
-    }
-    // The plinth where the foot meets the ground: a low block wider than the shaft, with its top.
-    {
-        const wp = w0 * TOWER_PLINTH.wide;
-        for (let k = 0; k < 4; k += 1) {
-            const o = ring([0, 0], 0, wp, k);
-            const next = ring([0, 0], 0, wp, (k + 1) % 4);
-            const v = [next[0] - o[0], next[1] - o[1], 0];
-            face(`tower-foot-${k}`, o, [0, 0, TOWER_PLINTH.high], v, `<rect class="u-tower-foot" width="${n(TOWER_PLINTH.high)}" height="${n(Math.hypot(v[0], v[1]))}"/>`);
+        // The two flanks: along the lean, from the front to the back.
+        for (const [name, side] of [["l", -1], ["r", 1]]) {
+            const o = at(r0.front, (side * r0.w) / 2, r0.h);
+            const top = at(r1.front, (side * r1.w) / 2, r1.h);
+            face(`tower-${i}-${name}`, o, sub(top, o), scale([-d[0], -d[1], 0], r0.front - r0.back), lr, () => "");
         }
-        const o = ring([0, 0], TOWER_PLINTH.high, wp, 0);
-        const [c1, c3] = [ring([0, 0], TOWER_PLINTH.high, wp, 1), ring([0, 0], TOWER_PLINTH.high, wp, 3)];
-        face("tower-foot-top", o, [c1[0] - o[0], c1[1] - o[1], 0], [c3[0] - o[0], c3[1] - o[1], 0], `<rect class="u-tower-foot" width="${n(wp)}" height="${n(wp)}"/>`);
     }
     // The observatory on the top: a block a little wider than the shaft there, its walls dark, with a band of glass round it, and a flat roof.
-    const [topAt, topW] = [at(1), wide(1) * TOWER_CAP.wide];
+    const top = rings[TOWER_RINGS];
+    const centre = (top.front + top.back) / 2;
+    const [hl, hw] = [TOWER_CAP.long / 2, TOWER_CAP.wide / 2];
+    const corners = [[hl, -hw], [hl, hw], [-hl, hw], [-hl, -hw]];
     for (let k = 0; k < 4; k += 1) {
-        const o = ring([topAt[0], 0], topAt[1], topW, k);
-        const next = ring([topAt[0], 0], topAt[1], topW, (k + 1) % 4);
-        const v = [next[0] - o[0], next[1] - o[1], 0];
-        const lv = Math.hypot(v[0], v[1]);
-        face(`tower-cap-${k}`, o, [0, 0, TOWER_CAP.high], v, `<rect class="u-tower-cap" width="${n(TOWER_CAP.high)}" height="${n(lv)}"/><rect class="u-tower-glass" x="${n(TOWER_CAP.high * 0.3)}" width="${n(TOWER_CAP.high * 0.45)}" height="${n(lv)}"/>`);
+        const [c0, c1] = [corners[k], corners[(k + 1) % 4]];
+        const o = at(centre + c0[0], c0[1], top.h);
+        const along = sub(at(centre + c1[0], c1[1], top.h), o);
+        const lv = Math.hypot(...along);
+        planes.push({ id: `tower-cap-${k}`, kind: "wall", o, u: [0, 0, TOWER_CAP.high], v: along, svg: `<rect class="u-tower-cap" width="${n(TOWER_CAP.high)}" height="${n(lv)}"/><rect class="u-tower-glass" x="${n(TOWER_CAP.high * 0.3)}" width="${n(TOWER_CAP.high * 0.45)}" height="${n(lv)}"/>` });
     }
     {
-        const o = ring([topAt[0], 0], topAt[1] + TOWER_CAP.high, topW, 0);
-        const [c1, c3] = [ring([topAt[0], 0], topAt[1] + TOWER_CAP.high, topW, 1), ring([topAt[0], 0], topAt[1] + TOWER_CAP.high, topW, 3)];
-        face("tower-cap-top", o, [c1[0] - o[0], c1[1] - o[1], 0], [c3[0] - o[0], c3[1] - o[1], 0], `<rect class="u-tower-cap" width="${n(topW)}" height="${n(topW)}"/>`);
+        const o = at(centre + corners[0][0], corners[0][1], top.h + TOWER_CAP.high);
+        const [c1, c3] = [at(centre + corners[1][0], corners[1][1], top.h + TOWER_CAP.high), at(centre + corners[3][0], corners[3][1], top.h + TOWER_CAP.high)];
+        planes.push({ id: "tower-cap-top", kind: "wall", o, u: sub(c1, o), v: sub(c3, o), svg: `<rect class="u-tower-cap" width="${n(TOWER_CAP.wide)}" height="${n(TOWER_CAP.long)}"/>` });
     }
     // The cables that held the roof, from the observatory to the roof: thin lines.
-    const from = ring([topAt[0], 0], topAt[1] + TOWER_CAP.high * 0.4, 0, 0);
+    const from = at(centre, 0, top.h + TOWER_CAP.high * 0.4);
     cables.forEach((to, i) => planes.push(...bar(`tower-cable-${i}`, "mast", from, to, 1.2, "u-tower-cable")));
     return planes;
 }
+/** The front's place along the lean at a height, kept in front of the back (a shaft is never turned inside out where the back's curve comes close to the front's line). */
+const frameFront = (front, back) => Math.max(front, back + 40);
 /** The point where a ray from `from` first meets a polygon, or `undefined`. */
 export function firstHit(poly, from, angle) {
     const [dx, dy] = [Math.cos(angle), Math.sin(angle)];
@@ -203,16 +198,39 @@ export function mastPlanes(real, c, z, masts) {
 export function realBuilding(real, top, centre, lift, steps, open = false, parts = { walls: true, roof: true }) {
     const items = [];
     const c = [centre[0], centre[1]];
+    // The Saddledome's building is its own: a round wall that leans out to a beam, under one saddle roof (`venue.saddle.ts`).
+    if (real.roof === "saddle" && real.saddle !== undefined) {
+        const cells = steps >= 100 ? SADDLE_CELLS.high : steps >= 48 ? SADDLE_CELLS.auto : SADDLE_CELLS.low;
+        if (parts.walls) {
+            const walls = [...saddleWalls(real.saddle, lift, cells, c), ...saddleTowers(real.saddle, lift)];
+            if (walls.length > 0)
+                items.push({ id: "shell", kind: "walls", at: centre, height: heightOf(walls), planes: walls });
+        }
+        if (parts.roof) {
+            const roof = saddleRoof(real.saddle, lift, cells);
+            if (roof.length > 0)
+                items.push({ id: "roof", kind: "roof", at: centre, height: heightOf(roof), planes: roof });
+        }
+        return items;
+    }
     const rim = Array.from({ length: steps }, (_, k) => rimPoint(real, c, (2 * Math.PI * k) / steps));
     const planes = [];
-    rim.forEach((a, i) => {
-        const b = rim[(i + 1) % steps];
-        const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
-        if (long < 1)
-            return;
-        const high = lift + (real.wall ?? wallAt(real, [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]));
-        planes.push({ ...shy(wall(`shell-${i}`, "wall", a[0], a[1], b[0], b[1], 0, high, `<rect class="${real.ivy === true ? "u-shell u-ivy" : real.brick === true ? "u-shell u-brick" : "u-shell"}" width="${n(long)}" height="${n(high)}"/>${real.podium === undefined ? "" : podiumBands(long, high, real.podium)}`), centre), fadeTo: 0.02 });
-    });
+    // A ribbed shell (the Olympic Stadium's) is its own: ribs and glazed bays in place of a drum of walls.
+    const ribbed = real.roof === "dome" && real.dome?.ribs !== undefined;
+    if (ribbed && parts.walls) {
+        const mid = [real.dome.rim.reduce((t, p) => t + p[0], 0) / real.dome.rim.length, real.dome.rim.reduce((t, p) => t + p[1], 0) / real.dome.rim.length];
+        const shell = ribbedWalls(real, mid, lift, steps);
+        items.push({ id: "shell", kind: "walls", at: centre, height: heightOf(shell), planes: shell });
+    }
+    if (!ribbed)
+        rim.forEach((a, i) => {
+            const b = rim[(i + 1) % steps];
+            const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
+            if (long < 1)
+                return;
+            const high = lift + (real.wall ?? wallAt(real, [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]));
+            planes.push({ ...shy(wall(`shell-${i}`, "wall", a[0], a[1], b[0], b[1], 0, high, `<rect class="${real.ivy === true ? "u-shell u-ivy" : real.brick === true ? "u-shell u-brick" : "u-shell"}" width="${n(long)}" height="${n(high)}"/>${real.podium === undefined ? "" : podiumBands(long, high, real.podium)}`), centre), fadeTo: 0.02 });
+        });
     if (parts.walls && planes.length > 0)
         items.push({ id: "shell", kind: "walls", at: centre, height: Math.max(...planes.map((p) => p.o[2])), planes });
     if (parts.walls && real.towers !== undefined) {
@@ -227,15 +245,17 @@ export function realBuilding(real, top, centre, lift, steps, open = false, parts
         return items;
     }
     if (parts.roof && real.roof === "dome" && real.dome !== undefined) {
-        // The cables run from the tower to the middle of the roof and a third of the way out each side of it.
+        // The cables run from the tower in a fan across the roof, from the crown out to either side of it, down to the ring.
         const rim = real.dome.rim;
         const mid = [rim.reduce((t, p) => t + p[0], 0) / rim.length, rim.reduce((t, p) => t + p[1], 0) / rim.length];
-        const reach = Math.max(...rim.map((p) => Math.hypot(p[0] - mid[0], p[1] - mid[1]))) / 3;
+        const reach = Math.max(...rim.map((p) => Math.hypot(p[0] - mid[0], p[1] - mid[1]))) / 2.4;
         const across = real.tower === undefined ? [0, 0] : [-(real.tower.top[1] - real.tower.base[1]), real.tower.top[0] - real.tower.base[0]];
         const long = Math.hypot(across[0], across[1]) || 1;
-        const high = lift + real.dome.low + (real.dome.crown - real.dome.low) * (1 - 0.1);
-        const cables = [[mid[0], mid[1], lift + real.dome.crown], ...[-1, 1].map((side) => [mid[0] + (across[0] / long) * reach * side, mid[1] + (across[1] / long) * reach * side, high])];
-        const planes = [...domeRoof(real.dome, lift, steps), ...(real.tower === undefined ? [] : towerPlanes(real.tower, lift, cables))];
+        const cables = [-1, -0.5, 0, 0.5, 1].map((f) => [mid[0] + (across[0] / long) * reach * f, mid[1] + (across[1] / long) * reach * f, lift + real.dome.crown - (real.dome.crown - real.dome.low) * 0.9 * Math.abs(f) ** 1.6]);
+        // Where the tower's axis meets the building's rim, seen from the top: how far the foot's front is from the top along the axis.
+        const hit = real.tower === undefined ? undefined : firstHit(real.footprint, real.tower.top, Math.atan2(real.tower.base[1] - real.tower.top[1], real.tower.base[0] - real.tower.top[0]));
+        const rimRun = real.tower === undefined || hit === undefined ? undefined : Math.hypot(hit[0] - real.tower.top[0], hit[1] - real.tower.top[1]);
+        const planes = [...(real.dome.ribs === undefined ? domeRoof(real.dome, lift, steps) : ribbedRoof(real, mid, lift, steps)), ...(real.tower === undefined ? [] : towerPlanes(real.tower, lift, cables, rimRun))];
         if (planes.length > 0)
             items.push({ id: "roof", kind: "roof", at: centre, height: heightOf(planes), planes });
         return items;

package/dist/venue.ribbed.d.ts

@@ -0,0 +1,18 @@
+import type { Pt, RealShell } from "./crowd.ts";
+import { type Plane } from "./turn.kit.ts";
+/** The rib's outer face's share of the way to the middle at a share `t` of the ring's height: a wing that stands out at the foot and sweeps in as it rises. */
+export declare const ribShare: (t: number) => number;
+/** `count` points equally spaced along a closed outline, the first at the point nearest `near` (the tower's side, so that the ribs there begin at the tower). */
+export declare function spaced(outline: readonly Pt[], count: number, near?: Pt): Pt[];
+/** The height of the roof panels over a point that stands the share `s` of the way from the middle to the outline (above the surface, in feet), for a ring at `ring` feet: the panels' surface, which the stands under them must stay below. 0 where the point is outside the wall's sweep. */
+export declare function ribbedSurfaceAt(s: number, ring: number): number;
+/**
+ * The shell's walls: the podium and the glazed stack of each bay (one plane), and the ribs between them that rise from the ground and sweep in to the ring. Each rib is its profile on a plane each side of its middle (a curved wing) and its outer
+ * face, one trapezoid, which is a small part (`fascia`) that the lower tiers leave out, as they leave out the ring's lip.
+ */
+export declare function ribbedWalls(real: RealShell, c: Pt, lift: number, steps: number): Plane[];
+/**
+ * The shell's roof: over each bay two pieces of the white roof panels, rising from the glazed stack to the ring, the ring's lip, and over the ring the membrane in two rings and a flat crown, its pieces crossed by the line of the
+ * cable net it is stretched on.
+ */
+export declare function ribbedRoof(real: RealShell, c: Pt, lift: number, steps: number): Plane[];

package/dist/venue.ribbed.js

@@ -0,0 +1,199 @@
+import { n, plane } from "./turn.kit.js";
+/** How far the ring's outer edge stands in from the outline, as a share of the way to the middle (ours: the sources give the roof's kind and its height, not its profile; the profile is drawn from photographs). */
+const RING = 0.775;
+/** How wide a rib is at its foot and at its top (the width of its outer face), how deep (how far it stands proud of the wall between two ribs) at its foot and at its top, in feet (ours). */
+const RIB = { wide: [48, 24], deep: [34, 14], flare: 0.225, bend: 2.63, side: 12 };
+/** How much of a wall is left where it stands between the eye and the field: the glazed bays give way almost entirely, the ribs stay as a ghost, so that the shell is still known from the near side (ours). */
+const BAY_FADE = 0.12;
+const RIB_FADE = 0.3;
+/** How far the bays are set back from the ribs' outer face at the foot and at the ring, as a share of the way to the middle (ours). */
+const SET_BACK = [0.075, 0.028];
+/** The height of the podium, of the glazed stack's top and of the ring's top, as shares of the ring's height, and of the ring's lip over it (ours, from photographs). */
+const LEVELS = { podium: 0.13, glass: 0.46, ring: 1, lip: 1.05 };
+/** The membrane's ring, from the ring in to the crown's edge, as shares of the way to the middle (ours: one ring of long pieces, a shallow cone, to keep the planes few). */
+const MEMBRANE = [RING, 0.16];
+const scaled = (c, p, s) => [c[0] + (p[0] - c[0]) * s, c[1] + (p[1] - c[1]) * s];
+const lerp = (a, b, t) => a + (b - a) * t;
+/** The rib's outer face's share of the way to the middle at a share `t` of the ring's height: a wing that stands out at the foot and sweeps in as it rises. */
+export const ribShare = (t) => 1 - RIB.flare * Math.min(1, Math.max(0, t)) ** RIB.bend;
+/** `count` points equally spaced along a closed outline, the first at the point nearest `near` (the tower's side, so that the ribs there begin at the tower). */
+export function spaced(outline, count, near) {
+    const edges = outline.map((p, i) => [p, outline[(i + 1) % outline.length]]);
+    const lengths = edges.map(([a, b]) => Math.hypot(b[0] - a[0], b[1] - a[1]));
+    const total = lengths.reduce((s, l) => s + l, 0);
+    const at = (distance) => {
+        let d = ((distance % total) + total) % total;
+        for (let i = 0; i < edges.length; i += 1) {
+            if (d <= lengths[i] || i === edges.length - 1) {
+                const t = lengths[i] === 0 ? 0 : Math.min(1, d / lengths[i]);
+                return [lerp(edges[i][0][0], edges[i][1][0], t), lerp(edges[i][0][1], edges[i][1][1], t)];
+            }
+            d -= lengths[i];
+        }
+        return outline[0];
+    };
+    let start = 0;
+    if (near !== undefined) {
+        let best = Infinity;
+        let run = 0;
+        edges.forEach(([a], i) => {
+            const gap = Math.hypot(a[0] - near[0], a[1] - near[1]);
+            if (gap < best)
+                [best, start] = [gap, run];
+            run += lengths[i];
+        });
+    }
+    return Array.from({ length: count }, (_, k) => at(start + (total * k) / count));
+}
+function cutOf(real, c, steps) {
+    const dome = real.dome;
+    const count = steps >= 56 ? dome.ribs.count : Math.round(dome.ribs.count / 2);
+    // The tower stands on the side its axis comes from: the ribs begin there.
+    return { points: spaced(real.footprint, count, real.tower?.base), c, ring: dome.low, crown: dome.crown };
+}
+/**
+ * One trapezoid of the shell: between the outline's points `a` and `b`, from the share `s0` of the way to the middle at the height `z0` to the share `s1` at `z1`, drawn in from the rib at each end by `m0` feet at its foot and `m1` at its top
+ * (the two chords stay parallel, so it is flat). `paint` draws on it, given its length up the slope, its width at the foot and its top's share of that.
+ */
+function band(id, kind, c, a, b, [s0, z0], [s1, z1], paint, [m0, m1] = [0, 0]) {
+    const long = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1;
+    const e = [(b[0] - a[0]) / long, (b[1] - a[1]) / long];
+    const [a0, a1] = [scaled(c, a, s0), scaled(c, a, s1)];
+    const o = [a0[0] + e[0] * m0, a0[1] + e[1] * m0, z0];
+    const top = [a1[0] + e[0] * m1, a1[1] + e[1] * m1, z1];
+    const [w0, w1] = [Math.max(1, long * s0 - 2 * m0), Math.max(1, long * s1 - 2 * m1)];
+    const v = [e[0] * w0, e[1] * w0, 0];
+    const u = [top[0] - o[0], top[1] - o[1], z1 - z0];
+    return plane(id, kind, o, u, v, paint(Math.hypot(...u), w0, w1 / w0));
+}
+/** How far a piece between two ribs stands back from the rib's middle, in feet: the rib's side planes stand `RIB.side` out from it, and the piece meets them. */
+const ribMargin = () => RIB.side + 0.4;
+const shape = (cls) => (up, wide, r) => `<polygon class="${cls}" points="0 0 ${n(up)} 0 ${n(up)} ${n(wide * r)} 0 ${n(wide)}"/>`;
+/** The bay's facade: the podium at its foot (a low dark band of openings, up to the share `low` of the plane's height) and over it the glazed stack, three bands of glass between thin ledges. */
+const facade = (low) => (up, wide, r) => {
+    const edge = (x) => wide * (1 - (1 - r) * (x / up));
+    const band = (f0, f1, m) => {
+        const [x0, x1] = [f0 * up, f1 * up];
+        return `<polygon class="u-glass" points="${n(x0)} ${n(m * edge(x0))} ${n(x1)} ${n(m * edge(x1))} ${n(x1)} ${n((1 - m) * edge(x1))} ${n(x0)} ${n((1 - m) * edge(x0))}"/>`;
+    };
+    const stack = [[0.06, 0.30], [0.38, 0.62], [0.70, 0.94]].map(([f0, f1]) => band(low + (1 - low) * f0, low + (1 - low) * f1, 0.03));
+    return `${shape("u-bay")(up, wide, r)}${band(0.35 * low, 0.8 * low, 0.04)}${stack.join("")}`;
+};
+/** The share of the way to the middle of the wall between two ribs at a share `t` of the ring's height: the ribs' outer face, set back. */
+const bayShare = (t) => ribShare(t) - lerp(SET_BACK[0], SET_BACK[1], Math.min(1, t));
+/** The height of the roof panels over a point that stands the share `s` of the way from the middle to the outline (above the surface, in feet), for a ring at `ring` feet: the panels' surface, which the stands under them must stay below. 0 where the point is outside the wall's sweep. */
+export function ribbedSurfaceAt(s, ring) {
+    let [lo, hi] = [0, 1];
+    for (let i = 0; i < 40; i += 1) {
+        const mid = (lo + hi) / 2;
+        if (bayShare(mid) > s)
+            lo = mid;
+        else
+            hi = mid;
+    }
+    return ring * LEVELS.lip * lo;
+}
+/** The outward unit direction at a point of the outline, for the planes that give way to the eye. */
+const outward = (c, p) => {
+    const d = Math.hypot(p[0] - c[0], p[1] - c[1]) || 1;
+    return [(p[0] - c[0]) / d, (p[1] - c[1]) / d];
+};
+/**
+ * The shell's walls: the podium and the glazed stack of each bay (one plane), and the ribs between them that rise from the ground and sweep in to the ring. Each rib is its profile on a plane each side of its middle (a curved wing) and its outer
+ * face, one trapezoid, which is a small part (`fascia`) that the lower tiers leave out, as they leave out the ring's lip.
+ */
+export function ribbedWalls(real, c, lift, steps) {
+    const cut = cutOf(real, c, steps);
+    const planes = [];
+    const Z = cut.ring;
+    const { points } = cut;
+    const t1 = LEVELS.glass;
+    const t0 = LEVELS.podium;
+    points.forEach((a, k) => {
+        const b = points[(k + 1) % points.length];
+        const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+        const shy = outward(c, mid);
+        const [sp0, sg] = [bayShare(0), bayShare(t1 / LEVELS.lip)];
+        planes.push({ ...band(`bay-${k}`, "wall", c, a, b, [sp0, lift], [sg, lift + Z * t1], facade(t0 / t1), [ribMargin(), ribMargin()]), shy, fadeTo: BAY_FADE });
+        planes.push(...rib(`rib-${k}`, c, a, Z, lift, shy));
+    });
+    return planes;
+}
+/** One rib at the outline's point `a`: its curved profile on the plane over its radius, and its outer face in two pieces. */
+function rib(id, c, a, Z, lift, shy) {
+    const lip = LEVELS.lip;
+    const R = Math.hypot(a[0] - c[0], a[1] - c[1]) || 1;
+    const [dx, dy] = [(a[0] - c[0]) / R, (a[1] - c[1]) / R];
+    // The plane stands over the radius from the ring's share to the foot's, its x running outwards and its y down from the top.
+    const [s0, top] = [RING - 0.02, Z * lip];
+    const o = [c[0] + dx * R * s0, c[1] + dy * R * s0, lift + top];
+    const wide = R * (1 - s0);
+    const steps = 8;
+    const t = (i) => i / steps;
+    const out = Array.from({ length: steps + 1 }, (_, i) => [R * (ribShare(t(i)) - s0), top - Z * lip * t(i)]);
+    const inner = out.map(([x, y], i) => [x - lerp(RIB.deep[0], RIB.deep[1], t(i)), y]);
+    const outline = [...out, ...inner.reverse()];
+    // The two sides of the rib: the same curved profile on a plane each side of its middle, so that the rib is closed from every side and the pieces between ribs meet it.
+    const [tx, ty] = [-dy, dx];
+    const outlineText = outline.map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
+    const planes = [-1, 1].map((side) => {
+        const at = [o[0] + tx * RIB.side * side, o[1] + ty * RIB.side * side, o[2]];
+        return { ...plane(`${id}${side < 0 ? "-l" : "-r"}`, "wall", at, [dx * wide, dy * wide, 0], [0, 0, -top], `<polygon class="u-rib" points="${outlineText}"/>`), shy, fadeTo: RIB_FADE };
+    });
+    // The outer face: one trapezoid along the wing's outer edge, from its foot to the ring, as wide as the rib is at each end.
+    const at = (tt, side) => {
+        const half = lerp(RIB.wide[0], RIB.wide[1], tt) / 2;
+        const share = ribShare(tt);
+        return [c[0] + dx * R * share + tx * half * side, c[1] + dy * R * share + ty * half * side, lift + Z * lip * tt];
+    };
+    {
+        const [p0, p1, p2] = [at(0, -1), at(1, -1), at(0, 1)];
+        const [u, v] = [[p1[0] - p0[0], p1[1] - p0[1], p1[2] - p0[2]], [p2[0] - p0[0], p2[1] - p0[1], p2[2] - p0[2]]];
+        const [lu, lv] = [Math.hypot(...u), Math.hypot(...v)];
+        const r = RIB.wide[1] / RIB.wide[0];
+        planes.push({ ...plane(`${id}-f`, "fascia", p0, u, v, `<polygon class="u-rib" points="0 0 ${n(lu)} 0 ${n(lu)} ${n(lv * r)} 0 ${n(lv)}"/>`), shy, fadeTo: RIB_FADE });
+    }
+    return planes;
+}
+/**
+ * The shell's roof: over each bay two pieces of the white roof panels, rising from the glazed stack to the ring, the ring's lip, and over the ring the membrane in two rings and a flat crown, its pieces crossed by the line of the
+ * cable net it is stretched on.
+ */
+export function ribbedRoof(real, c, lift, steps) {
+    const cut = cutOf(real, c, steps);
+    const planes = [];
+    const { points, ring: Z, crown } = cut;
+    const lip = LEVELS.lip;
+    const roofAt = (s) => lift + Z * lip + (crown - Z * lip) * (1 - (s / RING) ** 2);
+    const across = (id, a, b, from, to, cls, net, margin, kind = "roof") => {
+        const paint = (up, wide, r) => `${shape(cls)(up, wide, r)}${net ? `<path class="u-cable" d="M0 0L${n(up)} ${n(wide * r)}"/>` : ""}`;
+        const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+        return { ...band(id, kind, c, a, b, from, to, paint, margin), shy: outward(c, mid), fadeTo: 0.2 };
+    };
+    points.forEach((a, k) => {
+        const b = points[(k + 1) % points.length];
+        const s = (t) => bayShare(t / lip);
+        // The roof panels climb from the glazed stack's top to the ring's outer edge in two pieces; the ring's lip stands over it.
+        const mids = [[s(LEVELS.glass), lift + Z * LEVELS.glass], [s(LEVELS.ring), lift + Z * LEVELS.ring], [RING, lift + Z * lip]];
+        for (let j = 0; j < 2; j += 1)
+            planes.push(across(`roof-p${j}-${k}`, a, b, mids[j], mids[j + 1], j === 1 ? "u-rib" : "u-dome", false, [ribMargin(), ribMargin()], j === 1 ? "fascia" : "roof"));
+        // The membrane: rings in from the ring to the crown.
+        for (let j = 0; j < MEMBRANE.length - 1; j += 1)
+            planes.push(across(`roof-${j}-${k}`, a, b, [MEMBRANE[j], roofAt(MEMBRANE[j])], [MEMBRANE[j + 1], roofAt(MEMBRANE[j + 1])], "u-dome", j === 0, [0, 0]));
+    });
+    // The crown: a flat cap over the middle.
+    const top = points.map((p) => scaled(c, p, MEMBRANE[MEMBRANE.length - 1]));
+    const cap = capOver(top, lift + crown);
+    if (cap !== undefined)
+        planes.push(cap);
+    return planes;
+}
+/** A flat polygon at the height `z`, as one plane over its bounding box (the crown). */
+function capOver(poly, z) {
+    if (poly.length < 3)
+        return undefined;
+    const [x0, x1] = [Math.min(...poly.map((p) => p[0])), Math.max(...poly.map((p) => p[0]))];
+    const [y0, y1] = [Math.min(...poly.map((p) => p[1])), Math.max(...poly.map((p) => p[1]))];
+    const svg = `<polygon class="u-dome" points="${poly.map(([x, y]) => `${n(x - x0)},${n(y - y0)}`).join(" ")}"/>`;
+    return { ...plane("roof-crown", "roof", [x0, y0, z], [x1 - x0, 0, 0], [0, y1 - y0, 0], svg), fadeTo: 0.2 };
+}

package/dist/venue.saddle.d.ts

@@ -0,0 +1,48 @@
+import type { Pt, RealShell } from "./crowd.ts";
+import { type Plane, type V3 } from "./turn.kit.ts";
+/** The saddle's measure, in the drawing's frame: its middle, the radius of its round plan, the unit direction of the line through its two high points (and the one across it), and the heights of the high points and of the low rim (feet over the surface). */
+export type Saddle = NonNullable<RealShell["saddle"]>;
+/** The cells to a side of the roof's grid (the plan is 4 times that round the rim), and the rings of the wall, at each detail. */
+export declare const SADDLE_CELLS: {
+    readonly low: 8;
+    readonly auto: 10;
+    readonly high: 16;
+};
+/** How thick the beam round the roof's edge is, how far it overhangs the wall's top, how far the wall leans out over its height (a share of the height of the edge there), in feet or as a share (ours: measured on photographs, a hand's accuracy). */
+export declare const EAVE: {
+    readonly depth: 5;
+    readonly overhang: 7;
+    readonly lean: 0.14;
+};
+/** A pier stands on the wall at every this many facets, and the band of small windows lies between these shares of the wall's height (ours). */
+export declare const PIER_EVERY = 2;
+export declare const WINDOWS: {
+    readonly from: 0.4;
+    readonly to: 0.44;
+};
+/** The height of the roof over a point of the plan, above the surface, in feet: a hyperbolic paraboloid over the round plan, high along `axis` and low across it. */
+export declare function saddleHeight(s: Saddle, [x, y]: Pt): number;
+/**
+ * A quad of four corners (in order round it) as one plane: its first corner, its side to the second and its side to the fourth span the plane; the third corner is put where the plane has it (a quad of a doubly curved surface is not quite
+ * flat, and the plane is the nearest flat piece: within a foot or two at every cut). `paint` gets the corners in the plane's own feet, and the plane's own (unit) normal as it lies in the drawing.
+ */
+export declare function quadPlane(id: string, kind: Plane["kind"], corners: readonly [V3, V3, V3, V3], paint: (local: [Pt, Pt, Pt, Pt]) => string): Plane | undefined;
+/** The roof: the net of quads over the round plan, `cells` to a side, with the beam round its edge. Every plane is a roof's, cut away from above and, by its side, from the eye's; the beam is the edge of the roof's own item. */
+export declare function saddleRoof(s: Saddle, lift: number, cells: number): Plane[];
+/** The wall: a facet between each two points of the rim, leaning out from its foot to the beam, with a pier between every `PIER_EVERY` panels, the fine lines of its cladding and a few windows. Each gives way by the eye's side as a wall does. */
+export declare function saddleWalls(s: Saddle, lift: number, cells: number, centre: Pt): Plane[];
+/** The two stair towers at each end of the roof's high line, a round one and a square one, on the wall's foot at either side of the end: how tall each stands (a share of the wall there) and how big it is, in feet (ours: photographs show each, not its size). */
+export declare const TOWERS: {
+    readonly round: {
+        readonly turn: -24;
+        readonly radius: 11;
+        readonly share: 0.55;
+    };
+    readonly square: {
+        readonly turn: 24;
+        readonly half: 17;
+        readonly share: 0.45;
+    };
+};
+/** The stair towers: at each of the roof's two high points, a round tower and a square one against the wall, taller where the wall is. */
+export declare function saddleTowers(s: Saddle, lift: number): Plane[];