@kerros/viewer 0.0.0-stage → 0.1.0-rc.2

package/dist/map/SceneLayer.js

@@ -0,0 +1,1534 @@
+var Be = Object.defineProperty;
+var Pe = (E, i, e) => i in E ? Be(E, i, { enumerable: !0, configurable: !0, writable: !0, value: e }) : E[i] = e;
+var b = (E, i, e) => Pe(E, typeof i != "symbol" ? i + "" : i, e);
+import { makeDoor as Ge } from "./Doors.js";
+import { fenceGeometry as Fe } from "./fences.js";
+import * as v from "three";
+import Tt from "polygon-clipping";
+import { MercatorCoordinate as ae } from "maplibre-gl";
+import { legStepIndices as Ve, routeTrackImage as We, ROUTE_COLOR as le, TRACK_PIXELS as he, TRACK_TILE as ce } from "./route.js";
+import { toLngLat as de, objectPosition as fe, objectRotation as $e, add as ge, rotate as ut, openRing as zt, barrierEnds as pe, distance as xt, pointInRing as Rt, closeRing as wt, rectangle as at, objectArea as ue, ringArea as De } from "../model/geometry.js";
+import { floorOutline as It, mainAxis as _e } from "../model/walls.js";
+import { wallPieces as vt, objectRings as St, COLORS as yt } from "./features.js";
+import { shaftVoids as Gt, flights as He, stairModel as Ue, flightsAt as Ne, flightRun as Ze, servedFloors as Xe, isVertical as Et, reaches as qe } from "../model/vertical.js";
+import { makeFixture as Ye, makeRoof as Ke } from "./architecture.js";
+import { MaterialLibrary as Je } from "./materials.js";
+import { EXTERIOR_PRESETS as me } from "../model/materials.js";
+import { exteriorWalls as Qe } from "./exteriors.js";
+import { mergeGeometries as je } from "three/addons/utils/BufferGeometryUtils.js";
+import { SurfaceBatch as ti, metricUVs as Ot, splitWallFace as ei, OUTSIDE as ii, hitEntity as ve } from "./surfaces.js";
+import { excavationRings as si } from "./excavation.js";
+import { floorIndex as Mt, undergroundView as ni, MAX_CAGE_LEVELS as oi } from "./underground.js";
+import { UndergroundCage as ri, undergroundPit as ai } from "./UndergroundContext.js";
+import { walkNearPlane as li, includeSceneDepth as hi, syncLightingCamera as ci } from "./projection.js";
+import { FIXED as ye, ambient as we, sunlight as be } from "./lighting.js";
+import { FixtureLights as di } from "./FixtureLights.js";
+import { EYE as fi } from "./walkDimensions.js";
+import { rampJoins as gi } from "../model/ramps.js";
+import { stairGeometry as pi, spiralGeometry as ui } from "../model/stairGeometry.js";
+import { tallSpaceContext as mi } from "./walkSurfaces.js";
+import { walkVoidContext as vi, walkConnectionContext as yi } from "./walkContext.js";
+import { rampSections as wi, rampVoids as ke } from "./rampGeometry.js";
+import { makePool as bi, makeWaterSlide as xi, applyPoolCaustics as Mi } from "./water.js";
+import { cabinFloorVoids as Si, cabinDimensions as Ii, elevatorWalls as Ci, elevatorDoorWidth as xe } from "./elevators.js";
+import { CabinMaterials as Li } from "./CabinMaterials.js";
+import { REFLECTION_BODY as Ti, CabinMirror as ki } from "./CabinMirror.js";
+import { makeElevatorCabin as Ai, makeCabinDoor as zi } from "./ElevatorCabin.js";
+import { Passenger as Ri } from "./Passenger.js";
+import { LIFT as q, SLAB as $ } from "./levels.js";
+const Ei = 7e-3, Me = (E) => Ei * (E > 2e3 ? 0 : E > 200 ? 1 : E > 20 ? 2 : 3), Oi = 0.85, Se = 0.58, Ie = 0.05, Ct = 0.06, Bi = 0.35, Pi = 0.62, Gi = 0.3, Fi = 0.055, Vi = 0.17, Wi = (E, i, e) => E ? 0 : i - e, $i = (E, i, e) => {
+  var n;
+  return i ? e - (((n = E.active) == null ? void 0 : n.elevation) ?? 0) : E.elevation(e);
+}, Lt = (E, i) => Math.max(E + i + q, E + q + $ + fi + Bi);
+function Ce(E, i) {
+  const e = E.floors.find((o) => o.id === i);
+  if (!e) return;
+  const s = (e.mezzanine ? E.floors.filter(
+    (o) => !o.mezzanine && o.buildingId === e.buildingId && o.elevation < e.elevation && o.elevation + o.height > e.elevation
+  ).sort((o, l) => l.elevation - o.elevation)[0] : void 0) ?? e;
+  return { floor: s, soffit: Lt(0, s.elevation + s.height - e.elevation) };
+}
+const Bt = (E) => E.map((i) => [Math.round(i[0] * 1e4) / 1e4, Math.round(i[1] * 1e4) / 1e4]);
+function Le(E, i, e, n) {
+  var m;
+  const s = Mt(E), l = (s.objects.get(i) ?? []).filter((h) => {
+    var c;
+    return h.kind === "zone" && !h.parentId && !h.slope && ((c = h.rings) == null ? void 0 : c.length);
+  }), r = l.length ? l.map((h) => h.rings.map((c) => Bt(wt(c)))) : It(E, i).map((h) => [Bt(wt(h))]);
+  if (!r.length) return [];
+  try {
+    let h = Tt.union(r[0], ...r.slice(1));
+    const c = [...Gt(E, i, e, n), ...ke(E, i)];
+    return c.length && (h = Tt.difference(
+      h,
+      ...c.map((I) => [Bt(I)])
+    )), h;
+  } catch {
+    const h = (m = s.outlines.get(i)) == null ? void 0 : m.rings;
+    return h ? [h.map((c) => wt(c))] : [];
+  }
+}
+const Di = 42, Pt = "route:track", Q = (E) => E ? q + $ : Ct, _i = (E, i) => {
+  const e = (n, s) => {
+    let o = 1 / 0, l = -1 / 0;
+    for (const f of n)
+      f[s] < o && (o = f[s]), f[s] > l && (l = f[s]);
+    return [o, l];
+  };
+  for (const n of [0, 1]) {
+    const [s, o] = e(E, n), [l, f] = e(i, n);
+    if (o < l || f < s) return !1;
+  }
+  return !0;
+}, Hi = 0.4, Ui = 0.2, Te = 0.02;
+function Ni(E, i) {
+  const e = Math.max(2, Math.min(40, Math.round(i / Hi))), n = i / e, s = Math.max(Ui, E / e);
+  return Array.from({ length: e }, (o, l) => ({
+    at: n * (l + 0.5),
+    // The band hangs a riser below the slope line: the foot step's top is level with the lower comb
+    // plate, which is where a step really does emerge, and the head of the run stops a riser short
+    // of the upper one. That last riser is where the band's travel goes — a cycle puts every step
+    // where its neighbour was, so the step that climbs past the last visible one has to finish
+    // inside the head housing rather than above a landing that is now flush with the floor.
+    base: E * l / e - s,
+    going: n,
+    face: s
+  }));
+}
+class Ts {
+  constructor() {
+    b(this, "id", "kerros-3d");
+    b(this, "type", "custom");
+    b(this, "renderingMode", "3d");
+    b(this, "map");
+    b(this, "renderer");
+    b(this, "scene", new v.Scene());
+    b(this, "camera", (() => {
+      const i = new v.Camera();
+      return i.layers.enableAll(), i.layers.disable(Ti), i;
+    })());
+    b(this, "worldToClip", new v.Matrix4());
+    b(this, "clipToWorld", new v.Matrix4());
+    b(this, "transform", new v.Matrix4());
+    b(this, "center");
+    b(this, "unit", 1);
+    b(this, "project");
+    b(this, "stack", !1);
+    b(this, "walking", !1);
+    /** The walked floor has lamps of its own. Then the walk hands the interior over to them and
+     *  turns the general ceiling light down; a floor without any keeps the general light, or it is
+     *  a dark floor with a bright lid. */
+    b(this, "lampLit", !1);
+    b(this, "poolLitOnly", !1);
+    b(this, "poolOverview", !1);
+    /** Per-storey ghost strength for the things a stack is FOR — the floor plates that carry each
+     *  storey's plan — on the storeys ABOVE the one in focus. Shared out across however many of them
+     *  the stack layers up between the eye and the focus. */
+    b(this, "ghostAlpha", 0.17);
+    /** And for the storeys UNDER the one in focus, which are read through the active plate as well as
+     *  through everything above it and need the strength to survive both. Keeping the two apart is
+     *  also what lets the active plate be drawn between them — see the render-order pass. */
+    b(this, "underAlpha", 0.27);
+    b(this, "activeFloor", null);
+    b(this, "hovered", null);
+    b(this, "rebase", 0);
+    /** See sceneGround: what an authored elevation has to be shifted by to join the scene. */
+    b(this, "ground", 0);
+    b(this, "growth", 1);
+    b(this, "growthStart", 0);
+    b(this, "materials", new Je());
+    b(this, "cabinMaterials");
+    b(this, "passenger");
+    b(this, "fixtureLights");
+    b(this, "waterTime", { value: 0 });
+    b(this, "hasWater", !1);
+    b(this, "batch", new ti());
+    b(this, "highlight", new v.Group());
+    b(this, "selected", null);
+    /** Where the sun stands over this project right now, and whether that counts as evening. */
+    b(this, "sunState", ye.day);
+    b(this, "statuses", null);
+    b(this, "excavation", !1);
+    /** Only the part of the feed the scene is built from — where the cars are and whether doors stand
+     *  open. A tone changing from normal to alarm recolours a marker and must not rebuild the scene. */
+    b(this, "liftSignature", "");
+    /** Per-floor stairwell cut-outs; cleared with the scene. */
+    b(this, "voidCache", /* @__PURE__ */ new Map());
+    /** Moving parts, rebuilt with the scene each update — see `rig`. */
+    b(this, "rigs", []);
+    /** Where each moving part has got to, carried ACROSS rebuilds. The geometry is disposed with the
+     *  scene like everything else; this is not, or every lift car would jump back to the bottom of its
+     *  shaft on any edit, and every open door would slam. */
+    b(this, "rigState", /* @__PURE__ */ new Map());
+    /** Whether the last animation frame moved anything that casts a shadow. */
+    b(this, "shadowsMoved", !1);
+    b(this, "lastFrame", 0);
+    b(this, "revision", 0);
+    b(this, "depthScale", 1);
+    b(this, "buried", !1);
+    b(this, "presentedElevation", (i) => i);
+    b(this, "cage", new ri());
+    b(this, "sun");
+    /** The two lights that are not the sun, kept so the scene can be re-lit without being rebuilt. */
+    b(this, "skyLight");
+    b(this, "roomLight");
+    b(this, "route", null);
+    b(this, "routeStep", null);
+    b(this, "routeGroup", null);
+    b(this, "routeTile", null);
+    b(this, "mapStyle", {});
+    b(this, "xyCache", /* @__PURE__ */ new Map());
+    b(this, "markerCache", /* @__PURE__ */ new Map());
+    // Whether each marker is hidden behind geometry. Screen position is cheap and recomputed every
+    // frame; this is a raycast against the whole model and must NOT be. It survives camera movement and
+    // is only re-derived once the camera settles (or the scene is rebuilt).
+    b(this, "occlusionCache", /* @__PURE__ */ new Map());
+    b(this, "previousProjection", new v.Matrix4());
+    b(this, "previousScale", 0);
+    b(this, "previousSize", "");
+    b(this, "pickables", []);
+    b(this, "clipBounds", new v.Box3());
+    b(this, "clipBoundsDirty", !0);
+    /** A tiny procedural sky/ground gradient, prefiltered for image-based lighting. Without an
+     *  environment every MeshStandardMaterial is lit by two lights alone and reads flat; with one, every
+     *  surface picks up sky above and bounced ground below, which is most of what makes 3D look solid.
+     *  Built once per lighting mood and cached — PMREM generation is not cheap. */
+    b(this, "envCache", /* @__PURE__ */ new Map());
+    /** Ask for a repaint at the loop rate rather than at once, coalescing the requests so a dozen
+     *  escalators still only cost one frame between them. */
+    b(this, "loopTimer");
+  }
+  cabinFinishes() {
+    return this.cabinMaterials ?? (this.cabinMaterials = new Li(this.renderer));
+  }
+  wave() {
+    var i, e;
+    (i = this.passenger) == null || i.wave(performance.now() / 1e3), (e = this.map) == null || e.triggerRepaint();
+  }
+  setMapStyle(i) {
+    this.mapStyle = i ?? {};
+  }
+  onAdd(i, e) {
+    this.map = i, this.renderer = new v.WebGLRenderer({
+      canvas: i.getCanvas(),
+      context: e,
+      antialias: !0
+    }), this.renderer.autoClear = !1, this.renderer.shadowMap.enabled = !0, this.renderer.shadowMap.type = v.PCFSoftShadowMap, this.renderer.shadowMap.autoUpdate = !1, this.renderer.toneMapping = v.NeutralToneMapping, this.renderer.toneMappingExposure = 0.9;
+  }
+  environmentMap(i) {
+    const e = i ? "evening" : "day", n = this.envCache.get(e);
+    if (n || !this.renderer) return (n == null ? void 0 : n.texture) ?? null;
+    const s = document.createElement("canvas");
+    s.width = 512, s.height = 256;
+    const o = s.getContext("2d"), l = o.createLinearGradient(0, 0, 0, 256);
+    i ? (l.addColorStop(0, "#22293f"), l.addColorStop(0.42, "#5d5570"), l.addColorStop(0.52, "#c08a5f"), l.addColorStop(1, "#241f1c")) : (l.addColorStop(0, "#719dcc"), l.addColorStop(0.35, "#c0d5e5"), l.addColorStop(0.49, "#f6eedf"), l.addColorStop(0.54, "#b3ada0"), l.addColorStop(1, "#605f55")), o.fillStyle = l, o.fillRect(0, 0, 512, 256);
+    for (const [h, c, I] of [
+      [110, 83, 65],
+      [370, 58, 44]
+    ]) {
+      const w = o.createRadialGradient(h, c, 0, h, c, I);
+      w.addColorStop(0, i ? "rgba(249,188,139,.42)" : "rgba(255,252,239,.8)"), w.addColorStop(1, "rgba(255,255,255,0)"), o.fillStyle = w, o.fillRect(h - I, c - I, I * 2, I * 2);
+    }
+    const f = new v.CanvasTexture(s);
+    f.mapping = v.EquirectangularReflectionMapping, f.colorSpace = v.SRGBColorSpace;
+    const r = new v.PMREMGenerator(this.renderer), m = r.fromEquirectangular(f);
+    return f.dispose(), r.dispose(), this.renderer.resetState(), this.envCache.set(e, m), m.texture;
+  }
+  /** Move the existing lights to where a new sun puts them, without touching the geometry. Valid
+   *  only while the dusk treatment is unchanged — see the caller. */
+  relight(i, e, n) {
+    var l, f, r, m, h, c;
+    const s = we(
+      n,
+      this.poolOverview ? { kelvin: 6500, level: 1 } : (l = i.floors.find((I) => I.id === e)) == null ? void 0 : l.light
+    );
+    this.scene.environmentIntensity = this.poolLitOnly ? 0 : s.environment, (f = this.skyLight) == null || f.color.set(s.sky), (r = this.skyLight) == null || r.groundColor.set(s.ground), this.skyLight && (this.skyLight.intensity = this.poolLitOnly ? 0 : s.hemisphere), (m = this.roomLight) == null || m.color.set(s.interior), (h = this.roomLight) == null || h.groundColor.set(s.interiorBounce), this.roomLight && (this.roomLight.intensity = s.interiorLevel * (this.walking && this.lampLit ? 0.45 : 1));
+    const o = be(n);
+    this.sun && (this.sun.color.set(o.color), this.sun.intensity = this.poolLitOnly ? 0 : o.intensity, this.sun.position.set(...o.position), this.fitShadowCamera()), this.refreshShadows(), (c = this.map) == null || c.triggerRepaint();
+  }
+  /** Redraw every shadow map on the next frame: the sun's, and each lamp's. Shadows are drawn on
+   *  demand, and each light says for itself whether it is owed a redraw — the sun's map is one
+   *  2048² pass over the whole model and a lamp's is six, so a lamp swapping under a walker must
+   *  not cost the sun's as well. This is the "everything changed" case. */
+  refreshShadows() {
+    var i;
+    this.renderer && (this.sun && (this.sun.shadow.needsUpdate = !0), (i = this.fixtureLights) == null || i.invalidate(), this.renderer.shadowMap.needsUpdate = !0);
+  }
+  /** Point the sun at the model and shrink its shadow frustum to fit. A fixed +/-140 m box spends
+   *  most of a 2048 map on empty ground: a small building got a handful of texels and its shadows
+   *  came out as soft mush. Fitting to the real extent keeps texel density high whatever the scale. */
+  fitShadowCamera() {
+    const i = this.sun;
+    if (!i) return;
+    const e = new v.Box3();
+    if (this.scene.traverse((m) => {
+      m instanceof v.Mesh && m.castShadow && e.expandByObject(m);
+    }), e.isEmpty()) return;
+    const n = e.getCenter(new v.Vector3()), s = e.getSize(new v.Vector3());
+    i.target.position.copy(n), i.target.updateMatrixWorld();
+    const o = Math.max(s.x, s.y, s.z) || 1, l = i.position.clone().normalize();
+    i.position.copy(n).addScaledVector(l, o * 1.6 + 40), i.updateMatrixWorld();
+    const f = i.shadow.camera;
+    i.shadow.updateMatrices(i);
+    const r = new v.Box3();
+    for (const m of [e.min.x, e.max.x])
+      for (const h of [e.min.y, e.max.y])
+        for (const c of [e.min.z, e.max.z]) {
+          const I = new v.Vector3(m, h, c);
+          r.expandByPoint(I.clone().applyMatrix4(f.matrixWorldInverse)), !this.buried && c > 0 && (I.addScaledVector(l, -c / l.z), r.expandByPoint(I.applyMatrix4(f.matrixWorldInverse)));
+        }
+    Object.assign(f, {
+      left: r.min.x - 3,
+      right: r.max.x + 3,
+      top: r.max.y + 3,
+      bottom: r.min.y - 3,
+      near: Math.max(0.5, -r.max.z - 10),
+      far: -r.min.z + 10
+    }), f.updateProjectionMatrix();
+  }
+  xy(i) {
+    const e = `${i[0]},${i[1]}`, n = this.xyCache.get(e);
+    if (n) return n;
+    const s = ae.fromLngLat(de(i, this.project.origin)), o = [(s.x - this.center.x) / this.unit, -(s.y - this.center.y) / this.unit];
+    return this.xyCache.set(e, o), o;
+  }
+  /** Several extrusions welded into one moving part. An escalator's step band is twenty boxes that
+   *  travel together, and twenty meshes per flight — times a bank of four, times the flights in
+   *  view — is a draw call apiece for something that moves as one thing. Merged, it is one. */
+  parts(i, e, n = !0, s) {
+    const o = i.map(({ rings: m, base: h, height: c }) => {
+      const I = new v.Shape(m[0].map((d) => new v.Vector2(...this.xy(d))));
+      I.holes = m.slice(1).map((d) => new v.Path(d.map((S) => new v.Vector2(...this.xy(S)))));
+      const w = new v.ExtrudeGeometry(I, { depth: c, bevelEnabled: !1, steps: 1 });
+      w.translate(0, 0, h), Ot(w);
+      const y = w.getAttribute("position");
+      if (s) {
+        w.computeBoundingBox();
+        const d = w.boundingBox.getCenter(new v.Vector3()), S = w.getAttribute("uv"), p = w.getAttribute("normal"), [u, x] = s.across;
+        for (let a = 0; a < y.count; a++) {
+          const L = y.getX(a) - d.x, F = y.getY(a) - d.y, D = Math.abs(p.getZ(a)) > 0.5 ? (-L * x + F * u) / s.going + 0.5 : 0.2 + 0.6 * (y.getZ(a) - w.boundingBox.min.z) / Math.max(1e-3, c);
+          S.setXY(a, (L * u + F * x) / s.width + 0.5, D);
+        }
+      }
+      for (let d = 0; d < y.count; d++) y.setZ(d, this.present(y.getZ(d)));
+      return w.computeVertexNormals(), w.index ? w.toNonIndexed() : w;
+    }), l = o.length === 1 ? o[0] : je(o), f = new v.Mesh(l, s ? this.materials.escalator() : this.materials.solid(e));
+    f.castShadow = n, f.receiveShadow = !0;
+    const r = new v.Group();
+    return r.add(f), r;
+  }
+  /** Register a moving part. Called while the scene is being built; the geometry is fresh each time
+   *  and the position it has reached is not, so a car mid-ride keeps riding across an edit.
+   *
+   *  `settled` seeds the value the first time a part is ever seen, so opening a document does not
+   *  send every lift travelling up from the basement to wherever it actually is. */
+  rig(i, e, n, s, o, l = !1) {
+    this.rigState.has(i) || this.rigState.set(i, l ? 0 : n), o(e, this.rigState.get(i)), this.scene.add(e), this.rigs.push({ id: i, group: e, target: n, speed: s, apply: o, loop: l });
+  }
+  /** Advance every moving part toward its target. Returns true while anything is still moving, which
+   *  is what keeps asking the map to repaint — MapLibre draws on demand, so without that a ride would
+   *  advance one frame per mouse move. */
+  animate(i) {
+    let e = !1;
+    this.shadowsMoved = !1;
+    for (const n of this.rigs) {
+      const s = this.rigState.get(n.id) ?? n.target;
+      if (n.loop) {
+        const f = (s + n.speed * i) % n.target;
+        this.rigState.set(n.id, f), n.apply(n.group, f), e = !0;
+        continue;
+      }
+      if (Math.abs(s - n.target) < 1e-4) {
+        s !== n.target && this.rigState.set(n.id, n.target);
+        continue;
+      }
+      const o = n.speed * i, l = Math.abs(n.target - s) <= o ? n.target : s + Math.sign(n.target - s) * o;
+      this.rigState.set(n.id, l), n.apply(n.group, l), e = !0, this.shadowsMoved = !0;
+    }
+    return e;
+  }
+  paintSoon() {
+    this.loopTimer || (this.loopTimer = setTimeout(() => {
+      var i;
+      this.loopTimer = void 0, (i = this.map) == null || i.triggerRepaint();
+    }, Di));
+  }
+  /** One vertex, mapped by the view's depth transform — see sceneElevation. Geometry is built at
+   *  the elevations the document authored, so this is the last thing that touches a z before it
+   *  reaches the buffer. It ran in the stacked view only, which left a deep cutaway drawing its
+   *  plate at the compressed depth and everything around it at the real one. */
+  present(i) {
+    return this.buried && !this.walking ? this.presentedElevation(i) : i;
+  }
+  surface(i, e, n, s, o, l, f = !1, r = !1, m, h = !1, c, I) {
+    if (!i.length) return;
+    const w = new v.Shape(i[0].map((p) => new v.Vector2(...this.xy(p))));
+    w.holes = i.slice(1).map((p) => new v.Path(p.map((u) => new v.Vector2(...this.xy(u)))));
+    const y = n > 5e-3 ? new v.ExtrudeGeometry(w, {
+      depth: n,
+      bevelEnabled: !1,
+      steps: r && !f ? Math.min(24, Math.max(1, Math.ceil(n / 0.35))) : 1
+    }) : new v.ShapeGeometry(w);
+    if (y.translate(0, 0, e), Ot(y, I), r && !f) {
+      const p = y.getAttribute("position"), u = new Float32Array(p.count * 3);
+      for (let x = 0; x < p.count; x++) {
+        const a = Math.max(0, Math.min(1, (p.getZ(x) - e) / Oi)), L = Se + (1 - Se) * a ** 0.55;
+        u[x * 3] = u[x * 3 + 1] = u[x * 3 + 2] = L;
+      }
+      y.setAttribute("color", new v.BufferAttribute(u, 3));
+    }
+    if (this.buried && !this.walking && this.depthScale < 1) {
+      const p = y.getAttribute("position");
+      for (let u = 0; u < p.count; u++) p.setZ(u, this.present(p.getZ(u)));
+      y.computeVertexNormals();
+    }
+    const d = m ?? (f ? this.materials.ghost(s, typeof f == "number" ? f : this.ghostAlpha) : l ? this.materials.get(l, s) : this.materials.solid(s)), S = c && ei(y, c.map((p) => this.xy(p)));
+    if (S) {
+      const p = this.materials.get("plaster", "#eceae5");
+      this.batch.add(S, r && !f ? this.materials.shaded(p) : p, o, h);
+    }
+    this.batch.add(y, r && !f ? this.materials.shaded(d) : d, o, h);
+  }
+  /** A sloped area (garage ramp, loading incline): the plate's own footprint, but each vertex lifted
+   *  to its elevation along the slope axis, then given thickness along -Z so the deck reads solid
+   *  from below. Depth compression is applied per-vertex, exactly as for flat surfaces. */
+  slopedSurface(i, e, n, s, o, l = !1) {
+    for (const f of wi(i.rings, e)) {
+      const r = new v.Shape(f[0].map((u) => new v.Vector2(...this.xy(u))));
+      r.holes = f.slice(1).map((u) => new v.Path(u.map((x) => new v.Vector2(...this.xy(x)))));
+      const m = new v.ExtrudeGeometry(r, { depth: s, bevelEnabled: !1 });
+      m.translate(0, 0, -s), Ot(m);
+      const [h, c] = this.xy(e.axis[0]), [I, w] = this.xy(e.axis[1]), y = I - h, d = w - c, S = y * y + d * d, p = m.getAttribute("position");
+      for (let u = 0; u < p.count; u++) {
+        const x = S ? Math.max(0, Math.min(1, ((p.getX(u) - h) * y + (p.getY(u) - c) * d) / S)) : 0;
+        p.setZ(u, this.present(p.getZ(u) + e.high + (e.low - e.high) * x + n));
+      }
+      m.computeVertexNormals(), this.batch.add(
+        m,
+        l ? this.materials.ghost(o, typeof l == "number" ? l : this.ghostAlpha) : this.materials.solid(o),
+        i.id
+      );
+    }
+  }
+  /** The façade envelope for a set of levels: each level's slab, its exterior walls with their
+   *  authored finish, and the glazing punched into them. Interior partitions are deliberately left
+   *  out — from outside they are hidden work, and they used to produce seams along the façade. */
+  envelope(i, e, n, s) {
+    for (const o of i.objects) {
+      const l = e.get(o.floorId ?? "");
+      l && (o.kind === "zone" && o.rings && this.surface(o.rings, l.elevation + q, $, "#c8c5bd", o.id), o.kind === "window" && o.barrierId && n.has(o.barrierId) && this.opening(i, o, l.elevation));
+    }
+    for (const o of vt(i, null, !0))
+      if (e.has(o.floorId ?? "") && n.has(o.id)) {
+        const l = s.get(o.id);
+        this.surface([o.ring], o.base + Q(o.floorId), o.height - o.base, l.color, o.id, l.material);
+      }
+  }
+  opening(i, e, n) {
+    const s = fe(i, e), o = $e(i, e);
+    if (e.kind === "window") {
+      const l = i.barriers.find((d) => d.id === e.barrierId), f = Math.min(e.height, ((l == null ? void 0 : l.height) ?? e.height + 0.85) - 0.85);
+      if (f <= 0) return;
+      const r = n + Q(e.floorId) + 0.85, m = Math.min(0.08, f / 3, e.width / 3), h = Math.max(0.16, ((l == null ? void 0 : l.thickness) ?? 0.2) + 0.035), c = this.materials.metal("#b4b9ba"), I = this.materials.glass(this.sunState.evening), w = (d, S, p, u, x, a = h) => {
+        const L = ut([d, 0], o);
+        this.surface(
+          [at([s[0] + L[0], s[1] + L[1]], S, a, o)],
+          p,
+          u,
+          "#ffffff",
+          e.id,
+          void 0,
+          !1,
+          !1,
+          x
+        );
+      };
+      w(0, e.width + 0.08, r - 0.04, 0.065, this.materials.get("stone", "#b9b6ac"), h + 0.12), w(0, e.width, r, m, c), w(0, e.width, r + f - m, m, c);
+      for (const d of [-1, 1]) w(d * (e.width - m) / 2, m, r + m, f - m * 2, c);
+      w(0, e.width - m * 2, r + m, f - m * 2, I, 0.018);
+      const y = Math.max(1, Math.ceil(e.width / 1.45));
+      for (let d = 1; d < y; d++)
+        w(-e.width / 2 + d * e.width / y, 0.045, r + m, f - m * 2, c);
+    } else e.kind === "stairs" ? this.shaft(i, e, n, s, o) : e.kind === "elevator" ? this.lift(i, e, n, s, o) : ["door", "gate"].includes(e.kind) ? this.leaf(i, e, n, s, o) : this.surface(
+      St({ ...e, position: s, rotation: o }),
+      n + Q(e.floorId),
+      Math.min(e.height, 3),
+      e.color ?? yt[e.kind] ?? "#bfcac7",
+      e.id
+    );
+  }
+  /** A door as a leaf in a frame, standing open when the feed says it is.
+   *
+   *  In 3D a door had been a slab filling its whole opening — a door you could never walk through and
+   *  that looked identical whether it was open, closed or unmonitored. The plan has drawn the swing
+   *  for a long time; this is the same statement in three dimensions, hinged the same way, so the two
+   *  views agree about which side it opens from.
+   *
+   *  Unknown status means shut. The plan can draw the architectural swing symbol for "a door is here
+   *  and this is how it opens" because a symbol is allowed to be about the door rather than about its
+   *  state; a solid leaf in space is not, so it stays in the frame until something says otherwise. */
+  leaf(i, e, n, s, o) {
+    var S;
+    const l = i.barriers.find((p) => p.id === e.barrierId), f = (l == null ? void 0 : l.thickness) ?? 0.2, r = n + Q(e.floorId), m = Math.min(e.height, ((l == null ? void 0 : l.height) ?? e.height) - 0.02), h = Ge(e, f, m, this.materials), c = this.xy(s), I = this.xy(ge(s, ut([1, 0], o))), w = Math.atan2(I[1] - c[1], I[0] - c[0]), y = (p) => {
+      p.position.set(c[0], c[1], this.present(r)), p.scale.z = this.buried && !this.walking ? this.depthScale : 1, p.rotation.z = w;
+    };
+    y(h.frame);
+    for (const p of this.batch.addObject(h.frame, e.id)) this.scene.add(p);
+    h.frame.traverse((p) => {
+      p instanceof v.Mesh && p.geometry.dispose();
+    });
+    const d = (S = this.statuses) == null ? void 0 : S.get(e.feedId ?? "");
+    h.panels.forEach(({ group: p, setOpen: u }, x) => {
+      y(p), this.rig(
+        `${e.id}:leaf:${e.doorType ?? "hinged"}:${x}`,
+        p,
+        d != null && d.open ? 1 : 0,
+        1.4,
+        (a, L) => u(L)
+      );
+    });
+  }
+  /** The inward-facing edge of an exterior wall.
+   *
+   *  Which face is the inside is not a property of the wall — it is a question about the building
+   *  around it — so it is answered the only way it can be: step off the wall each way and see which
+   *  side lands within the floor's footprint. A wall with no footprint to be inside of (an outbuilding
+   *  wall, a fence read as exterior) has no interior face. */
+  interiorFace(i, e, n) {
+    const s = It(i, e.floorId ?? n);
+    if (!s.length) return null;
+    const o = zt(e.ring);
+    if (o.length < 3) return null;
+    const l = i.barriers.find((I) => I.id === e.id);
+    if (!l || l.thickness < 0.03) return null;
+    const [f, r] = pe(i, l), m = xt(f, r), h = (r[0] - f[0]) / m, c = (r[1] - f[1]) / m;
+    for (let I = 0; I < o.length; I++) {
+      const w = o[I], y = o[(I + 1) % o.length], d = xt(w, y);
+      if (d < 0.05 || Math.abs((y[0] - w[0]) * c - (y[1] - w[1]) * h) > 1e-6 * d) continue;
+      const S = (y[1] - w[1]) / d, p = -(y[0] - w[0]) / d, u = [(w[0] + y[0]) / 2, (w[1] + y[1]) / 2], x = [u[0] + S * 0.3, u[1] + p * 0.3];
+      if (s.some((a) => Rt(x, a)))
+        return [w, y];
+    }
+    return null;
+  }
+  /** An area's rings with the shafts that climb through its level, and the ramps that drive through
+   *  it, cut out of them.
+   *
+   *  `through` says which plate is being cut: a floor is open where something arrives up through it,
+   *  a ceiling where something sets off up through it. They are not the same holes — the bottom of a
+   *  run departs without arriving and the top arrives without departing — and on a criss-cross
+   *  escalator bank they are at opposite ends of the same box.
+   *
+   *  `wells` is whether a stairwell may be punched at all — a hole onto a storey nobody is drawing
+   *  is worse than no hole. A ramp is not subject to it: what is under a ramp's hole is the ramp.
+   *
+   *  Cheap when there is nothing to cut, which is the usual case: a floor with no shaft through it
+   *  gets its own rings back untouched, and one with a shaft pays a clip only for the areas the
+   *  shaft actually lands in. */
+  withVoids(i, e, n, s, o = "floor", l = !0) {
+    const f = `${n}|${o}|${l}`;
+    let r = this.voidCache.get(f);
+    if (r || (r = l ? Gt(i, n, s, { through: o, lowest: this.buried || this.walking ? -1 / 0 : -0.01 }) : [], r = [...r, ...ke(i, n, o)], o === "floor" && (r = [
+      ...r,
+      ...i.objects.filter((h) => {
+        var c;
+        return h.floorId === n && h.water && ((c = h.rings) == null ? void 0 : c.length);
+      }).map((h) => h.rings[0]),
+      // In POV the car supplies its own floor, including at the lowest landing. Stairwell
+      // cuts are disabled when no lower storey is drawn; leaving the room finish here put
+      // carpet or bath tiles above the car's floor and made the cabin look like a pool.
+      ...this.walking ? Si(i, n, s) : []
+    ]), this.voidCache.set(f, r)), !r.length || !e.length) return e.length ? [e] : [];
+    const m = r.filter((h) => _i(h, e[0]));
+    if (!m.length) return e.length ? [e] : [];
+    try {
+      return Tt.difference(
+        [e.map((c) => wt(c))],
+        ...m.map((c) => [c])
+      );
+    } catch {
+      return e.length ? [e] : [];
+    }
+  }
+  /** A stair, spiral or escalator, drawn as the climb it actually makes.
+   *
+   *  The flights come from the levels the document says the shaft serves, not from whatever storey
+   *  happens to sit above it, and each is drawn at the elevation of the level it leaves — so the
+   *  flight arriving at the level you are standing on is there, coming up through the floor, instead
+   *  of being filed invisibly under the storey below. */
+  shaft(i, e, n, s, o) {
+    var I;
+    const l = e.color ?? yt[e.kind] ?? "#bfcac7", f = ((I = i.floors.find((w) => w.id === e.floorId)) == null ? void 0 : I.elevation) ?? 0, r = He(i, e), m = Ue(i, e), h = this.stack ? r : (() => {
+      const { up: w, down: y } = Ne(i, e, this.activeFloor);
+      return [y, w].filter((d) => !!d);
+    })();
+    if (!h.length) {
+      this.surface(St({ ...e, position: s, rotation: o }), n + Q(e.floorId), 0.18, l, e.id);
+      return;
+    }
+    const c = this.buried || this.walking ? h : h.filter((w) => w.from.elevation > -0.01);
+    if (c.length)
+      for (const w of c) {
+        const y = n + (w.from.elevation - f) + Q(e.floorId);
+        if (m === "spiral") {
+          this.spiral(e, s, y, w.rise, l);
+          continue;
+        }
+        const d = r.indexOf(w), S = d + 1 < r.length && c.includes(r[d + 1]);
+        this.flight(e, Ze(i, e, w.rise, m, d), y, w.rise, l, m, !S);
+      }
+  }
+  /** A straight climb: treads for a stair, a ribbed deck between flat landing plates for an
+   *  escalator. Both run along the object's own depth axis, which is where the plan put them. */
+  flight(i, e, n, s, o, l, f = !0) {
+    var S;
+    const { at: r, half: m, pad: h, incline: c, topT: I, footT: w, rotation: y } = e;
+    if (l === "escalator") {
+      const p = Ni(s, c), u = p[0].going, x = p[0].face, a = s / p.length, L = Math.max(0.24, a + 0.06), F = m - w;
+      this.surface(
+        [at(r(w + F / 2), i.width, F, y)],
+        n - (a + x + 0.08),
+        a + x + 0.08 + Te,
+        o,
+        i.id
+      ), f && this.surface(
+        [at(r(I - h / 2), i.width, h, y)],
+        n + s - L,
+        L + Te,
+        o,
+        i.id
+      );
+      const D = { ...i, rings: [at(r((I + w) / 2), i.width, c, y)] };
+      this.slopedSurface(D, { axis: [r(I), r(w)], high: n + s, low: n }, -x, 0.3, "#9aa5a1");
+      const nt = (N) => ({
+        rings: [at(r(w - N.at), i.width - 0.12, u * 1.02, y)],
+        base: n + N.base,
+        height: x
+      }), U = (S = this.statuses) == null ? void 0 : S.get(i.feedId ?? ""), _ = ((U == null ? void 0 : U.travel) ?? i.travel ?? "up") === "down" ? -1 : 1, et = (U == null ? void 0 : U.running) ?? !0, ot = this.xy(r(0)), A = this.xy(ge(r(0), ut([1, 0], y))), P = {
+        across: [A[0] - ot[0], A[1] - ot[1]],
+        width: i.width - 0.12,
+        going: u * 1.02
+      };
+      if (this.stack || !et) {
+        const N = this.parts(p.map(nt), o, !1, P);
+        N.userData.entityId = i.id, this.scene.add(N);
+      } else {
+        const N = _ > 0 ? { at: -u / 2, base: -a - x } : { at: c + u / 2, base: s - x }, st = this.parts([N, ...p].map(nt), o, !1, P), H = this.xy(r(0)), J = this.xy(r(-u * _)), rt = this.present(n + a * _) - this.present(n);
+        this.rig(
+          `${i.id}:steps:${Math.round(n * 100)}`,
+          st,
+          1,
+          // Half a metre a second along the incline is an ordinary escalator — a step a second.
+          0.5 / Math.hypot(u, a),
+          (O, Y) => O.position.set((J[0] - H[0]) * Y, (J[1] - H[1]) * Y, rt * Y),
+          !0
+        );
+      }
+      for (const N of [-1, 1]) {
+        const st = [N * (i.width / 2 - 0.06), 0], H = ut(st, y), J = r((I + w) / 2), rt = {
+          ...i,
+          rings: [at([J[0] + H[0], J[1] + H[1]], 0.1, c, y)]
+        };
+        this.slopedSurface(
+          rt,
+          {
+            axis: [
+              [r(I)[0] + H[0], r(I)[1] + H[1]],
+              [r(w)[0] + H[0], r(w)[1] + H[1]]
+            ],
+            high: n + s + 0.95,
+            low: n + 0.95
+          },
+          0,
+          0.08,
+          "#8f9a96"
+        );
+      }
+      return;
+    }
+    const d = pi(i, e, s, l);
+    for (const p of d.landings)
+      this.surface([p.ring], n + p.height - 0.06, 0.1, o, i.id, i.material);
+    for (const p of d.lanes) {
+      const u = p.head[0] - p.foot[0], x = p.head[1] - p.foot[1], a = Math.hypot(u, x) / p.steps, L = Math.atan2(x, u) * 180 / Math.PI - 90;
+      for (let F = 0; F < p.steps; F++) {
+        const D = (F + 0.5) / p.steps;
+        this.surface(
+          [at([p.foot[0] + u * D, p.foot[1] + x * D], p.width, a * 1.02, L)],
+          n + p.base + p.rise * F / p.steps,
+          p.rise / p.steps + 0.04,
+          o,
+          i.id,
+          i.material
+        );
+      }
+    }
+  }
+  /** A lift: the shaft as tall as the levels it serves, its doors on the level you are standing on,
+   *  and the car where the feed says it is.
+   *
+   *  It used to be a 1.2 m box — shorter than the doors it was supposed to contain — because the
+   *  generic object path capped elevators there to stop them blocking the view. A lift is not
+   *  furniture: it is a hole through the building, and drawing it as one is the only way the plan
+   *  shows that floors 2 and 7 are on the same shaft. Above the level in focus it turns to ghost, so
+   *  it reads as continuing without becoming a column in front of everything else. */
+  lift(i, e, n, s, o) {
+    var et, ot;
+    const l = e.color ?? yt[e.kind] ?? "#bfcac7", f = ((et = i.floors.find((A) => A.id === e.floorId)) == null ? void 0 : et.elevation) ?? 0, r = Xe(i, e), m = n + Q(e.floorId), h = (A) => n + (A.elevation - f) + Q(e.floorId), c = i.floors.find((A) => A.id === this.activeFloor);
+    if (r.length < 2) {
+      this.surface(St({ ...e, position: s, rotation: o }), m, Math.min(e.height, 2.4), l, e.id);
+      return;
+    }
+    const w = (this.buried ? r : r.filter((A) => A.elevation > -0.01))[0] ?? r[0], y = Math.max(h(r[0]), this.buried ? -1 / 0 : n - f + Q(e.floorId)), d = h(r[r.length - 1]) + (r[r.length - 1].height ?? e.height), S = c ? Math.min(d, n + (c.elevation - f) + Q(e.floorId) + (c.height ?? 3)) : d, p = (A, P, N) => {
+      if (!(P - A < 0.05))
+        for (const [st, H] of [
+          ["front", 0],
+          ["right", 90],
+          ["back", 180],
+          ["left", 270]
+        ]) {
+          const J = H % 180 ? e.depth : e.width, rt = H % 180 ? e.width : e.depth, O = xe(e, H), Y = o + H, it = (tt, Z, V, dt) => {
+            if (dt <= V) return;
+            const gt = ut([tt, rt / 2 - 0.045], Y);
+            this.surface(
+              [at([s[0] + gt[0], s[1] + gt[1]], Z, 0.09, Y)],
+              V,
+              dt - V,
+              N ? l : "#b4bab7",
+              e.id,
+              void 0,
+              N
+            );
+          };
+          if (!(e.doorSides ?? ["front"]).includes(st)) {
+            it(0, J, A, P);
+            continue;
+          }
+          for (const tt of [-1, 1]) it(tt * (J + O) / 4, (J - O) / 2, A, P);
+          let j = A;
+          for (const tt of r) {
+            const Z = h(tt), V = Math.min(2.3, tt.height - 0.35);
+            Z + V <= A || Z >= P || (it(0, O, j, Math.min(P, Z)), j = Math.max(j, Z + V));
+          }
+          it(0, O, j, P);
+        }
+    };
+    p(y, S, !1), this.walking || p(S, d, Math.max(this.ghostAlpha, Vi));
+    const u = (ot = this.statuses) == null ? void 0 : ot.get(e.feedId ?? ""), x = (u == null ? void 0 : u.targetFloorId) ?? (u == null ? void 0 : u.carFloorId) ?? null, a = r.find((A) => A.id === x && (this.buried || A.elevation > -0.01)) ?? w, L = Math.min(2.5, a.height - 0.35), F = {
+      ...e,
+      position: s,
+      rotation: o,
+      ...Ii(e)
+    }, D = at(s, F.width, F.depth, o), nt = this.walking && (c == null ? void 0 : c.id) === a.id, U = nt ? Ai(F, L, this.cabinFinishes(), (c == null ? void 0 : c.code) ?? (c == null ? void 0 : c.name) ?? "", !!(u != null && u.moving)) : this.parts(
+      [
+        { rings: [D], base: 0, height: 0.1 },
+        { rings: [D], base: L, height: 0.08 },
+        ...Ci(F, !0).map((A) => ({ rings: [A], base: 0.1, height: L - 0.1 }))
+      ],
+      "#dfe6e3"
+    );
+    if (nt) {
+      const A = this.xy(s), P = this.xy([
+        s[0] + Math.cos(o * Math.PI / 180),
+        s[1] + Math.sin(o * Math.PI / 180)
+      ]);
+      U.position.set(A[0], A[1], 0), U.rotation.z = Math.atan2(P[1] - A[1], P[0] - A[0]);
+    }
+    u != null && u.carFloorId && !u.targetFloorId && this.rigState.set(`${e.id}:car`, h(a));
+    const _ = u != null && u.carTravelSeconds && u.carTravelSeconds > 0 ? Math.max(
+      1.5,
+      Math.abs(h(a) - (this.rigState.get(`${e.id}:car`) ?? h(a))) / u.carTravelSeconds
+    ) : 1.5;
+    if (this.rig(`${e.id}:car`, U, h(a), _, (A, P) => {
+      A.position.z = this.present(P) - this.present(0), A.visible = !this.walking || !!(u != null && u.moving) || !!(u != null && u.targetFloorId) || (c == null ? void 0 : c.id) === a.id;
+    }), c && r.some((A) => A.id === c.id)) {
+      const A = Math.min(2.3, (c.height ?? 3) - 0.35), P = Math.abs((this.rigState.get(`${e.id}:car`) ?? h(a)) - h(c)) < 0.25, N = !!(u != null && u.open) && P;
+      for (const st of e.doorSides ?? ["front"]) {
+        const H = { front: 0, right: 90, back: 180, left: 270 }[st], J = o + H, rt = (H % 180 === 0 ? e.depth : e.width) / 2 - 0.13, O = ut([0, rt], J), Y = [s[0] + O[0], s[1] + O[1]], it = this.xy(Y), j = this.xy([Y[0] + Math.cos(J * Math.PI / 180), Y[1] + Math.sin(J * Math.PI / 180)]);
+        for (const tt of [-1, 1]) {
+          const Z = zi(xe(e, H), A, tt, this.cabinFinishes());
+          Z.group.position.set(it[0], it[1], this.present(h(c) + 0.015)), Z.group.rotation.z = Math.atan2(j[1] - it[1], j[0] - it[0]), Z.group.scale.z = (this.present(h(c) + A) - this.present(h(c))) / A, this.rig(`${e.id}:door:${st}:${tt}`, Z.group, N ? 1 : 0, 2.5, (V, dt) => Z.update(dt));
+        }
+      }
+    }
+  }
+  /** A spiral: wedge treads winding around a central pole.
+   *
+   *  Its exits are wherever it is served — a spiral passing three levels with a landing on each is
+   *  one object serving three floors, which the document could already say and nothing drew. */
+  spiral(i, e, n, s, o) {
+    const l = ui(i, e, s);
+    for (const f of l.wedges)
+      this.surface([wt(f.ring)], n + f.height - 0.07, 0.07, o, i.id);
+    this.surface([at(e, l.inner * 2, l.inner * 2, 0)], n, s, "#9aa3a0", i.id);
+  }
+  update(i, e, n, s, o = ye.day, l = null, f = !1, r = !1) {
+    var Wt, $t, Dt, _t, Ht, Ut, Nt, Zt, Xt, qt, Yt, Kt, Jt, Qt, jt, te, ee, ie, se, ne;
+    const m = o.evening, h = l ? [...l.values()].filter(
+      (t) => t.carFloorId !== void 0 || t.targetFloorId !== void 0 || t.open !== void 0 || t.running !== void 0 || t.travel
+    ).map(
+      (t) => `${t.feedId}:${t.carFloorId ?? ""}:${t.targetFloorId ?? ""}:${t.carTravelSeconds ?? ""}:${t.open ?? ""}:${t.moving ?? ""}:${t.running ?? ""}:${t.travel ?? ""}`
+    ).sort().join("|") : "";
+    if (r && this.activeFloor !== e)
+      for (const t of this.rigState.keys()) (t.endsWith(":car") || t.includes(":door:")) && this.rigState.delete(t);
+    this.statuses = l;
+    const c = this.project === i && this.stack === n && this.walking === r && this.activeFloor === e && this.liftSignature === h && this.excavation === f && this.scene.children.length > 0;
+    if (c && this.sunState === o) {
+      this.selected !== s && (this.selected = s, this.refreshHighlight());
+      return;
+    }
+    if (c && this.sunState.evening === o.evening) {
+      this.sunState = o, this.relight(i, e, o), this.selected !== s && (this.selected = s, this.refreshHighlight());
+      return;
+    }
+    this.project !== i && this.xyCache.clear(), this.voidCache.clear(), this.disposeScene(), clearTimeout(this.loopTimer), this.loopTimer = void 0, this.rigs = [], this.project = i, this.stack = n, this.walking = r, this.lampLit = !!r && !!e && i.objects.some((t) => t.floorId === e && t.kind === "light" && !!t.light);
+    const I = (($t = (Wt = i.floors.find((t) => t.id === e)) == null ? void 0 : Wt.light) == null ? void 0 : $t.level) === 0 && i.objects.some((t) => t.floorId === e && !!t.water);
+    this.poolLitOnly = r && I, this.poolOverview = !r && I, this.activeFloor = e, this.selected = s, this.sunState = o, this.liftSignature = h, this.excavation = f, this.revision++, this.batch.chunk = r ? 20 : 0;
+    const w = Qe(i), y = Mt(i), d = y.floors, S = new Map(i.buildings.map((t) => [t.id, t])), p = new Map(i.barriers.map((t) => [t.id, t])), u = new Map(
+      i.barriers.map((t) => {
+        var C, B;
+        const g = (B = S.get(((C = d.get(t.floorId ?? "")) == null ? void 0 : C.buildingId) ?? "")) == null ? void 0 : B.exteriorPreset;
+        return [
+          t.id,
+          w.has(t.id) ? g ? me[g] : t.material ? { material: t.material, color: t.color ?? "#c8c3b7" } : me.limestone : {
+            material: t.material ?? (t.kind === "wall" ? "plaster" : void 0),
+            // An interior wall is plastered, and plaster is near-white. COLORS.wall is the grey
+            // a wall is DRAWN in — a stroke on a plan has to read against a pale floor, so it is
+            // mid-grey by necessity — and standing that grey up as a surface, shaded and with
+            // contact shadow at its foot, made every partition read as bare concrete. A fence
+            // keeps its drawn colour: it has no plaster and is not a room's wall.
+            color: t.color ?? (t.kind === "wall" ? "#eef0f3" : yt[t.kind])
+          }
+        ];
+      })
+    ), x = ni(i, e, n), a = x.active, L = x.buried;
+    this.buried = L, this.depthScale = x.depthScale, this.presentedElevation = x.elevation, this.rebase = n || r ? 0 : (a == null ? void 0 : a.elevation) ?? 0;
+    const F = Wi(n, this.rebase, (a == null ? void 0 : a.elevation) ?? 0);
+    this.ground = F;
+    const D = L && n && x.compressed && !!a, nt = new Set(
+      D ? x.levels.filter((t) => t.elevation > a.elevation).map((t) => t.id) : []
+    ), U = new Set(
+      n && a ? x.levels.filter((t) => t.buildingId === a.buildingId && t.elevation < a.elevation).map((t) => t.id) : []
+    );
+    this.center = ae.fromLngLat(de([0, 0], i.origin)), this.unit = this.center.meterInMercatorCoordinateUnits(), this.transform.makeTranslation(this.center.x, this.center.y, 0).scale(new v.Vector3(this.unit, -this.unit, this.unit));
+    const _ = we(
+      o,
+      this.poolOverview ? { kelvin: 6500, level: 1 } : (Dt = i.floors.find((t) => t.id === e)) == null ? void 0 : Dt.light
+    );
+    this.renderer && (this.renderer.toneMappingExposure = r ? 0.68 : 0.9), this.scene.environment = this.environmentMap(m), this.scene.environmentRotation.set(Math.PI / 2, 0, 0), this.scene.environmentIntensity = this.poolLitOnly ? 0 : _.environment;
+    const et = new v.HemisphereLight(_.sky, _.ground, this.poolLitOnly ? 0 : _.hemisphere);
+    et.position.set(0, 0, 1), et.layers.enableAll(), this.scene.add(et), this.skyLight = et;
+    const ot = new v.HemisphereLight(
+      _.interior,
+      _.interiorBounce,
+      r && this.lampLit ? _.interiorLevel * 0.45 : _.interiorLevel
+    );
+    ot.position.set(0, 0, 1), this.scene.add(ot), this.roomLight = ot;
+    const A = be(o), P = new v.DirectionalLight(A.color, this.poolLitOnly ? 0 : A.intensity);
+    P.position.set(...A.position);
+    const N = new v.DirectionalLight(
+      m ? "#7f90bd" : "#cfe0f2",
+      this.poolLitOnly ? 0 : m ? 0.16 : 0.18
+    );
+    N.layers.enableAll(), N.position.set(m ? -80 : 85, m ? 60 : 55, 45), this.scene.add(N), P.layers.enableAll(), P.castShadow = !0, P.shadow.autoUpdate = !1, P.shadow.mapSize.set(2048, 2048), P.shadow.bias = -15e-5, P.shadow.normalBias = 0.025, Object.assign(P.shadow.camera, { left: -140, right: 140, top: 140, bottom: -140, near: 1, far: 500 }), this.scene.add(P), this.scene.add(P.target), this.sun = P;
+    const st = (t) => {
+      var g;
+      return !!t && (((g = d.get(t)) == null ? void 0 : g.elevation) ?? 0) < 0;
+    }, H = !!a && x.levels.some((t) => t.buildingId === a.buildingId && t.elevation < a.elevation), J = (t, g) => Math.max(0.035, Math.min(0.38, 1 - t ** (1 / Math.max(1, g))));
+    this.ghostAlpha = J(Pi, x.levels.filter((t) => t.elevation > ((a == null ? void 0 : a.elevation) ?? 0)).length), this.underAlpha = J(Gi, x.levels.filter((t) => t.elevation < ((a == null ? void 0 : a.elevation) ?? 0)).length);
+    const rt = (t, g = !1) => {
+      var C;
+      return g ? Fi : a && (((C = d.get(t ?? "")) == null ? void 0 : C.elevation) ?? 0) < a.elevation ? this.underAlpha : this.ghostAlpha;
+    }, O = a != null && a.mezzanine && !n ? i.floors.filter((t) => t.buildingId === a.buildingId && t.elevation < a.elevation).sort((t, g) => g.elevation - t.elevation)[0] : void 0, Y = a && !n ? i.floors.filter(
+      (t) => t.mezzanine && t.buildingId === a.buildingId && t.id !== a.id && t.elevation > a.elevation && t.elevation < a.elevation + a.height
+    ) : [], it = new Map(
+      !n && !r && a ? x.levels.filter((t) => t.elevation >= 0 && t.elevation < a.elevation && t.id !== (O == null ? void 0 : O.id)).map((t) => [t.id, t]) : []
+    ), j = L && !n && !r && a ? x.levels.filter((t) => t.elevation < a.elevation && t.id !== (O == null ? void 0 : O.id)).sort((t, g) => g.elevation - t.elevation)[0] : void 0, tt = r ? mi(i, e) : [], Z = new Set(tt.map((t) => t.floorId).filter(Boolean)), V = r && a && e ? vi(i, a, Ce(i, e).floor) : void 0, dt = r && a ? yi(i, a, y.primary).filter(
+      (t) => t.id !== (O == null ? void 0 : O.id) && !Y.some((g) => g.id === t.id) && !Z.has(t.id)
+    ) : [], gt = new Set(dt.map((t) => t.id)), kt = [...new Map([...(V == null ? void 0 : V.levels) ?? [], ...dt].map((t) => [t.id, t])).values()], Ae = new Set(
+      [...U, ...it.keys(), ...Z, O == null ? void 0 : O.id, j == null ? void 0 : j.id, e].filter(
+        Boolean
+      )
+    ), ze = (t) => this.walking || n || x.levels.some((g) => {
+      var C;
+      return g.elevation < (((C = d.get(t)) == null ? void 0 : C.elevation) ?? 0) && g.id !== t && Ae.has(g.id);
+    }), lt = (t) => {
+      var g;
+      return t ? this.rebase + ((((g = d.get(t)) == null ? void 0 : g.elevation) ?? (a == null ? void 0 : a.elevation) ?? 0) - ((a == null ? void 0 : a.elevation) ?? 0)) : F;
+    }, Ft = /* @__PURE__ */ new Map(), At = (t) => {
+      if (!t) return;
+      let g = Ft.get(t);
+      if (!g) {
+        const C = this.xy([0, 0]), B = this.xy(ut([1, 0], _e(i, t))), z = xt(C, B);
+        g = [(B[0] - C[0]) / z, (B[1] - C[1]) / z], Ft.set(t, g);
+      }
+      return g;
+    }, ft = (t) => $i(x, r, t), Re = n ? i.objects : (
+      // Deduplicated: a shaft filed under the storey below reaches this one, and the carried
+      // levels bring their own copy of the same object.
+      [
+        ...new Map(
+          [
+            ...y.objects.get(null) ?? [],
+            ...O ? y.objects.get(O.id) ?? [] : [],
+            ...Y.flatMap((t) => y.objects.get(t.id) ?? []),
+            ...tt,
+            // Openings in the carried walls need their doors and glazing as well.
+            ...dt.flatMap(
+              (t) => (y.objects.get(t.id) ?? []).filter((g) => g.kind === "door" || g.kind === "window")
+            ),
+            ...e ? y.objects.get(e) ?? [] : [],
+            // A stair that climbs to this level belongs on it, even though it is filed under the
+            // one it starts from. Without this the flight you are standing at the top of is not
+            // drawn.
+            ...e ? y.reaching.get(e) ?? [] : [],
+            // And a driveway that surfaces belongs to the street as much as to the deck it leaves.
+            // It is filed on the deck, so the site view — which iterates the site's own objects —
+            // never saw it, and the garage came out with no mouth at the kerb.
+            ...e === null ? i.objects.filter((t) => t.slope && Math.max(t.slope.high, t.slope.low) >= -0.01) : [],
+            // A ramp is a floor that is two floors. It is filed on the deck it leaves, so the deck
+            // it arrives at drew nothing: from P2 the ramp down from P1 stopped existing, and a
+            // car came up out of a plate with no way onto it. Both decks it joins, then — the
+            // levels its own slope starts and ends at, rather than every storey the incline passes
+            // through. The driveway out to Mannerheimintie crosses -4.2, -6.6 and -9 a hundred
+            // metres away under the street, and it has nothing to do with any of them.
+            ...a ? i.objects.filter(
+              (t) => {
+                var g;
+                return gi(t, a.elevation) && ((g = d.get(t.floorId ?? "")) == null ? void 0 : g.buildingId) === a.buildingId;
+              }
+            ) : []
+          ].map((t) => [t.id, t])
+        ).values()
+      ]
+    );
+    for (const t of Re) {
+      if (L && (t.floorId === null || a && ((_t = d.get(t.floorId)) == null ? void 0 : _t.buildingId) !== a.buildingId))
+        continue;
+      const g = e === null && !!t.slope && Math.max(t.slope.high, t.slope.low) >= -0.01;
+      if (!L && st(t.floorId) && !gt.has(t.floorId) && !(Et(t.kind) && qe(i, t, e)) && !g || Et(t.kind) && !y.primary.has(t.id)) continue;
+      const C = Et(t.kind);
+      if (t.floorId && nt.has(t.floorId) && !C) continue;
+      const B = !D && (t.kind === "room" || t.kind === "zone" || !!t.slope);
+      if (t.floorId && U.has(t.floorId) && !C && !B || D && t.floorId !== e && t.kind !== "zone") continue;
+      const z = n ? ((Ht = d.get(t.floorId ?? "")) == null ? void 0 : Ht.elevation) ?? 0 : lt(t.floorId), X = t.floorId !== null && (t.kind === "room" || t.kind === "zone"), K = e !== null && t.floorId === e, T = !!(n && e !== null && t.floorId && t.floorId !== e), G = T && rt(t.floorId, !(t.kind === "room" || t.kind === "zone")), M = n && K && H, W = ((Nt = (Ut = this.mapStyle).objectColor) == null ? void 0 : Nt.call(Ut, t)) ?? (K || T ? t.color ?? yt[t.kind] ?? "#e6e8e1" : X && !t.material ? (
+        // A carried level under a cutaway is background: one neutral, so it reads as context
+        // for the storey in focus rather than competing with it.
+        "#e5e4df"
+      ) : t.color ?? yt[t.kind] ?? "#e6e8e1");
+      if (t.water && ((Zt = t.rings) != null && Zt.length)) {
+        T || (this.scene.add(
+          bi(t, (k) => this.xy(k), this.present(z + q + $), this.materials, this.waterTime, r)
+        ), this.hasWater = r);
+        continue;
+      }
+      if (t.slide) {
+        T || this.scene.add(xi(t, (k) => this.xy(k), this.present(z + q + $), this.materials));
+        continue;
+      }
+      if (t.kind === "fixture" || t.kind === "landscape") {
+        if (T) continue;
+        const k = Ye(
+          t,
+          (R) => this.xy(R),
+          z + (t.floorId ? q + $ : Ct),
+          this.materials,
+          m
+        );
+        if (L && !r && z < 0) {
+          const R = k.position.z, ht = Math.max(t.height, 0.01);
+          k.position.z = this.present(R), k.scale.z = (this.present(R + ht) - this.present(R)) / ht;
+        }
+        for (const R of this.batch.addObject(k, t.id, t.floorId === null)) this.scene.add(R);
+        continue;
+      }
+      if (t.rings && t.slope) {
+        this.slopedSurface(t, t.slope, q + $ + F, $, W, G);
+        const [k, R] = t.slope.axis, ht = xt(k, R), bt = wt(t.rings[0]);
+        for (let mt = 1; mt < bt.length; mt++) {
+          const ct = bt[mt - 1], pt = bt[mt], oe = xt(ct, pt), re = ((pt[0] - ct[0]) * (R[0] - k[0]) + (pt[1] - ct[1]) * (R[1] - k[1])) / (oe * ht);
+          if (!Number.isFinite(re) || Math.abs(re) < 0.98) continue;
+          const Oe = {
+            ...t,
+            rings: [
+              at(
+                [(ct[0] + pt[0]) / 2, (ct[1] + pt[1]) / 2],
+                oe,
+                0.18,
+                Math.atan2(pt[1] - ct[1], pt[0] - ct[0]) * 180 / Math.PI
+              )
+            ]
+          };
+          this.slopedSurface(Oe, t.slope, q + $ + F + 0.16, 0.16, "#c7bd91", G);
+        }
+        continue;
+      }
+      if (t.rings) {
+        if (t.kind === "building" && e !== null) continue;
+        const k = t.floorId !== null, R = ["office", "container"].includes(t.kind), ht = z + (k ? (t.kind === "room" ? q + $ + 0.015 : q) + Me(ue(t)) : t.kind === "parcel" ? 0.02 : Ct), bt = R ? t.height : k ? t.kind === "room" ? Ie : $ : 0.04, mt = k && t.floorId ? this.withVoids(i, t.rings, t.floorId, y.primary, "floor", ze(t.floorId)) : [t.rings];
+        for (const ct of mt)
+          this.surface(
+            ct,
+            ht,
+            bt,
+            W,
+            t.id,
+            // The floor you are standing on used to be the one surface with no finish at all, which left
+            // the largest expanse in the frame as flat untextured colour. Give it the same plaster as
+            // the levels below — it is subtle enough not to compete with the plan, and without it a
+            // whole storey reads as paper.
+            T ? void 0 : t.material ?? (X ? "plaster" : void 0),
+            G,
+            !1,
+            M && X ? this.materials.plate(W) : (
+              // Walking, the floor is the one surface that can say where the light is, and only
+              // because you see it along rather than down onto it.
+              r && X && !T && t.material !== "carpet" ? this.materials.polished(this.materials.get(t.material ?? "plaster", W)) : void 0
+            ),
+            !k,
+            void 0,
+            At(t.floorId)
+          );
+      } else ["stairs", "elevator", "turnstile", "door", "gate", "window"].includes(t.kind) ? (!T || C) && this.opening(i, t, z) : ["office", "container", "storage"].includes(t.kind) && this.surface(
+        St(t),
+        z + Q(t.floorId),
+        t.height,
+        W,
+        t.id,
+        T ? void 0 : t.material,
+        G,
+        !1,
+        void 0,
+        t.floorId === null
+      );
+    }
+    for (const t of [...D ? U : [], ...j ? [j.id] : []]) {
+      if (!L && st(t)) continue;
+      const g = n ? ((Xt = d.get(t)) == null ? void 0 : Xt.elevation) ?? 0 : lt(t);
+      for (const C of Le(i, t, y.primary, { lowest: L ? -1 / 0 : -0.01 }))
+        this.surface(C, g + q + $, $, "#e5e4df", `shell:${t}`, void 0, n && rt(t));
+    }
+    if (r && e && a) {
+      const { floor: t, soffit: g } = Ce(i, e), C = this.materials.luminous("#f0f1ee", _.interior, 0.8 * (((qt = a.light) == null ? void 0 : qt.level) ?? 1), "ceiling"), B = this.materials.luminous("#f2f3ef", _.interior, 0.7 * (((Yt = a.light) == null ? void 0 : Yt.level) ?? 1), "tile"), z = tt.filter(
+        (M) => {
+          var W, k;
+          return M.ceilingHeight && ((W = M.rings) == null ? void 0 : W.length) && (((k = d.get(M.floorId)) == null ? void 0 : k.elevation) ?? 0) < a.elevation;
+        }
+      ), X = (M) => {
+        if (!(V != null && V.ceilingOpenings.length)) return M;
+        try {
+          return Tt.difference(
+            M,
+            ...V.ceilingOpenings.map((W) => [W])
+          );
+        } catch {
+          return M;
+        }
+      };
+      for (const M of [...y.objects.get(t.id) ?? [], ...z]) {
+        if (!((Kt = M.rings) != null && Kt.length) || M.kind !== "room" && M.kind !== "zone" || M.water || M.slope || !M.ceilingHeight && z.some((k) => Rt(M.position, k.rings[0]))) continue;
+        const W = M.ceilingHeight !== void 0 ? Lt(
+          0,
+          (((Jt = d.get(M.floorId)) == null ? void 0 : Jt.elevation) ?? a.elevation) + M.ceilingHeight - a.elevation
+        ) : g;
+        for (const k of X(this.withVoids(i, M.rings, t.id, y.primary, "ceiling")))
+          this.surface(
+            k,
+            W - Me(ue(M)),
+            $,
+            "#f0f1ee",
+            `ceiling:${M.id}`,
+            void 0,
+            !1,
+            !1,
+            M.material === "tile" ? B : C,
+            !1,
+            void 0,
+            At(t.id)
+          );
+      }
+      const K = i.floors.filter(
+        (M) => M.buildingId === a.buildingId && M.elevation >= t.elevation + t.height - 0.01
+      ).sort((M, W) => M.elevation - W.elevation)[0], T = Math.max(
+        g + $,
+        K ? Lt(lt(K.id), K.height) : g + a.height
+      ), G = Gt(i, t.id, y.primary, {
+        through: "ceiling",
+        lowest: L ? -1 / 0 : -0.01
+      });
+      if (!kt.length)
+        for (const [M, W] of G.entries())
+          this.surface([W], T, $, "#d9dad6", `well:${e}:${M}`);
+      for (const M of kt) {
+        if (M.id === (O == null ? void 0 : O.id) || Y.some((R) => R.id === M.id) || Z.has(M.id)) continue;
+        const W = lt(M.id), k = (y.objects.get(M.id) ?? []).find(
+          (R) => R.kind === "zone" && !R.parentId && !R.slope && R.material
+        );
+        for (const R of Le(i, M.id, y.primary, { lowest: -1 / 0 }))
+          this.surface(
+            R,
+            W + q,
+            $,
+            (k == null ? void 0 : k.color) ?? "#deddd6",
+            `atrium-plate:${M.id}`,
+            (k == null ? void 0 : k.material) ?? "plaster",
+            !1,
+            !1,
+            void 0,
+            !1,
+            void 0,
+            At(M.id)
+          );
+        if (gt.has(M.id) && !(V != null && V.levels.some((R) => R.id === M.id)))
+          for (const R of It(i, M.id))
+            for (const ht of M.elevation < a.elevation ? this.withVoids(i, [R], M.id, y.primary, "ceiling") : [[R]])
+              this.surface(
+                ht,
+                Lt(W, M.height),
+                $,
+                "#e4e2db",
+                `connection-ceiling:${M.id}`,
+                "ceiling"
+              );
+      }
+      if (V != null && V.roof)
+        for (const M of It(i, V.roof.id))
+          this.surface(
+            [M],
+            lt(V.roof.id) + V.roof.height + q,
+            $,
+            "#e4e2db",
+            `atrium-roof:${V.roof.id}`,
+            "ceiling"
+          );
+    }
+    const Ee = [
+      ...vt(i, e, n),
+      ...O ? vt(i, O.id, !1) : [],
+      ...Y.flatMap((t) => vt(i, t.id, !1)),
+      // Distant atrium levels retain their authored envelope and open railings. A synthetic
+      // wall around every outline ring incorrectly sealed the hole from floor to ceiling.
+      ...kt.filter((t) => t.id !== (O == null ? void 0 : O.id) && !Y.some((g) => g.id === t.id) && !Z.has(t.id)).flatMap(
+        (t) => vt(i, t.id).filter(
+          (g) => {
+            var C;
+            return gt.has(t.id) || w.has(g.id) || ((C = p.get(g.id)) == null ? void 0 : C.kind) === "fence";
+          }
+        )
+      ),
+      ...[...Z].filter((t) => t !== (O == null ? void 0 : O.id) && !Y.some((g) => g.id === t)).flatMap(
+        (t) => vt(i, t, !1).filter(
+          (g) => tt.some(
+            (C) => {
+              var B;
+              return C.floorId === t && ((B = C.rings) == null ? void 0 : B.length) && g.ring.some((z) => Rt(z, C.rings[0]));
+            }
+          )
+        )
+      )
+    ];
+    for (const t of Ee) {
+      if (L && (t.floorId === null || a && ((Qt = d.get(t.floorId)) == null ? void 0 : Qt.buildingId) !== a.buildingId) || !L && st(t.floorId) && !gt.has(t.floorId) || t.floorId && nt.has(t.floorId) || t.floorId && U.has(t.floorId) && !w.has(t.id) || D && t.floorId !== e && !w.has(t.id)) continue;
+      const g = u.get(t.id), C = p.get(t.id), B = d.get(t.floorId ?? "");
+      if (r && B && !B.mezzanine && w.has(t.id) && t.height >= B.height - $ - 0.01) {
+        const X = i.floors.filter((T) => T.buildingId === B.buildingId && !T.mezzanine && T.elevation > B.elevation).sort((T, G) => T.elevation - G.elevation)[0], K = X ? X.elevation - B.elevation - t.height - $ : 0;
+        K > 0.01 && this.surface(
+          [t.ring],
+          lt(t.floorId) + Q(t.floorId) + t.height,
+          K,
+          g.color,
+          `plenum:${t.id}`,
+          g.material
+        );
+      }
+      const z = n && e !== null && !!t.floorId && t.floorId !== e && rt(t.floorId, !0);
+      if (C.kind === "fence") {
+        const [X, K] = pe(i, C).map((M) => this.xy(M)), T = Fe(
+          X,
+          K,
+          t.ring.map((M) => this.xy(M)),
+          t.base + Q(t.floorId) + (n ? 0 : lt(t.floorId)),
+          t.height - t.base,
+          C.thickness
+        ), G = T.getAttribute("position");
+        for (let M = 0; M < G.count; M++) G.setZ(M, this.present(G.getZ(M)));
+        T.computeVertexNormals(), this.batch.add(
+          T,
+          z ? this.materials.ghost(g.color, z) : this.materials.metal(g.color),
+          t.id,
+          t.floorId === null
+        );
+        continue;
+      }
+      this.surface(
+        [t.ring],
+        t.base + Q(t.floorId) + (n ? 0 : lt(t.floorId)),
+        t.height - t.base,
+        g.color,
+        t.id,
+        z ? void 0 : g.material,
+        z,
+        // Only where a wall actually starts at its floor. A piece that begins part-way up — the strip
+        // over a door, say — has no junction to darken and would just get a dirty smear.
+        t.base < 0.01,
+        void 0,
+        // A fence or a garden wall stands out of doors and is lit like the ground it stands on.
+        t.floorId === null,
+        // Assign plaster to the actual inner face. A separate skin competed with brick in the
+        // depth buffer, especially at oblique angles and through the long hall.
+        w.has(t.id) && !z && g.material && !["plaster", "tile"].includes(g.material) ? this.interiorFace(i, t, e) : null
+      );
+    }
+    if (!L && (n || e === null)) {
+      for (const t of i.buildings)
+        if (t.roof && (!n || !a || t.id !== a.buildingId)) {
+          const g = Ke(t.roof, (C) => this.xy(C), t.id, this.materials);
+          for (const C of this.batch.addObject(g, t.id, !0)) this.scene.add(C);
+        }
+    }
+    if (it.size && this.envelope(i, it, w, u), !n && e === null && !L) {
+      const t = new Map(i.floors.filter((g) => g.elevation >= 0).map((g) => [g.id, g]));
+      this.envelope(i, t, w, u);
+      for (const g of i.buildings) {
+        if (g.roof) continue;
+        const C = i.floors.filter((z) => z.buildingId === g.id && z.elevation >= 0).sort((z, X) => z.elevation - X.elevation).at(-1), B = C && ((jt = y.outlines.get(C.id)) == null ? void 0 : jt.rings);
+        C && B && this.surface(B, C.elevation + C.height, $, "#747976", g.id, "roof");
+      }
+    }
+    if (L && f && !r) {
+      const t = y.outlines.get((a == null ? void 0 : a.id) ?? ((te = x.levels[0]) == null ? void 0 : te.id) ?? ""), g = si(i, x.levels, n ? 1 / 0 : a == null ? void 0 : a.elevation), C = g.length ? g : (ee = t == null ? void 0 : t.rings) != null && ee[0] ? [zt(t.rings[0])] : [], B = ft((a == null ? void 0 : a.elevation) ?? 0), z = Math.min(
+        B,
+        j ? ft(j.elevation) : B,
+        ...(y.objects.get(e ?? "") ?? []).filter((T) => T.slope).map((T) => ft(Math.min(T.slope.low, T.slope.high)))
+      ), X = n ? ft(x.levels.reduce((T, G) => Math.min(T, G.elevation), 0)) - 2.5 : z - 2.5, K = x.levels.filter((T) => T.elevation < 0).map((T) => ft(T.elevation));
+      for (const T of C) {
+        const G = T.map((k) => this.xy(k)), M = G.reduce((k, R) => k + R[0], 0) / G.length, W = G.reduce((k, R) => k + R[1], 0) / G.length;
+        this.scene.add(
+          ai(
+            G.map(([k, R]) => [M + (k - M) * 1.025, W + (R - W) * 1.025]),
+            B,
+            X,
+            K
+          )
+        );
+      }
+    }
+    if (L && a && f && !r && (!n || D)) {
+      const t = x.levels.filter((T) => T.elevation > a.elevation && (n || T.elevation <= 0)).sort((T, G) => T.elevation - G.elevation), g = Math.max(1, Math.ceil((t.length - 1) / (oi - 1))), C = t.filter((T, G) => G % g === 0 || G === t.length - 1), B = [];
+      let z = [], X = 0;
+      for (const T of C) {
+        const G = y.outlines.get(T.id);
+        if (!G) continue;
+        const M = zt(G.rings[0]);
+        B.push(M.map((R) => new v.Vector3(...this.xy(R), ft(T.elevation) + q)));
+        const W = T.mezzanine ? 0 : Math.abs(De(M));
+        if (z.length && W <= X) continue;
+        X = W;
+        const k = Math.max(1, Math.ceil(M.length / 16));
+        z = M.filter((R, ht) => ht % k === 0).map((R) => this.xy(R));
+      }
+      const K = t.at(-1);
+      this.cage.configure(
+        B,
+        z,
+        ft(a.elevation) + q,
+        K ? ft(K.elevation + (n ? K.height : 0)) : 0,
+        m
+      ), this.cage.setBearing(((ie = this.map) == null ? void 0 : ie.getBearing()) ?? 0), this.scene.add(this.cage);
+    }
+    const Vt = this.present((n ? (a == null ? void 0 : a.elevation) ?? 0 : lt(e)) + q + $);
+    if (r && e) {
+      const t = [...y.objects.get(e) ?? [], ...tt].filter((g) => g.kind === "light" && g.light).map((g) => g.floorId === e ? g : { ...g, height: g.height + lt(g.floorId) });
+      t.length && (this.fixtureLights = new di(this.scene, t, (g) => this.xy(g), Vt, this.materials));
+    }
+    if (r && (this.passenger = new Ri(this.cabinFinishes().environment), this.scene.add(this.passenger)), this.batch.finish(this.scene), this.hasWater && e && Mi(this.scene, i, e, (t) => this.xy(t), Vt, this.waterTime), n && a) {
+      for (const t of this.scene.children)
+        if (t instanceof v.Mesh) {
+          const g = Array.isArray(t.material) ? t.material[0] : t.material;
+          if (!g.transparent || g.depthWrite) continue;
+          t.geometry.computeBoundingBox(), t.renderOrder = (((se = t.geometry.boundingBox) == null ? void 0 : se.min.z) ?? 0) >= this.present(a.elevation) ? 1 : -1;
+        }
+    }
+    if (!L) {
+      const t = new v.Box3().setFromObject(this.scene);
+      if (!t.isEmpty()) {
+        const g = t.getSize(new v.Vector3()), C = t.getCenter(new v.Vector3()), B = Math.max(24, g.z * 4), z = new v.Mesh(
+          new v.PlaneGeometry(g.x + B * 2, g.y + B * 2),
+          new v.ShadowMaterial({
+            color: m ? "#282637" : "#3d4950",
+            // A weak sun casts a weak shadow. Held at a fixed darkness, a midwinter noon threw a
+            // shadow as black as midsummer's across a city it was barely lighting.
+            opacity: m ? 0.34 : 0.1 + 0.2 * _.day,
+            depthWrite: !1
+          })
+        );
+        z.position.set(C.x, C.y, F + 0.012), z.layers.set(ii), z.receiveShadow = !0, z.raycast = () => {
+        }, this.scene.add(z);
+      }
+    }
+    this.fitShadowCamera(), this.scene.add(this.highlight), this.refreshHighlight(), this.pickables = [], this.scene.traverse((t) => {
+      !(t instanceof v.Mesh) || !(Array.isArray(t.material) ? t.material : [t.material]).some((C) => C.visible && (!C.transparent || C.depthWrite)) || (t.userData.entityId || t.userData.entityIds || t.userData.spans) && this.pickables.push(t);
+    }), this.buildRoute(), this.refreshShadows(), (ne = this.map) == null || ne.triggerRepaint();
+  }
+  /** Show/replace the 3D route. When only the active step changed, restyle materials in place;
+   * otherwise rebuild the route group. Route state is retained across update() rebuilds — every
+   * rebuild re-runs buildRoute with FRESH materials, because disposeScene disposes all mesh
+   * materials and a cached material would die silently on the next floor switch. */
+  setRoute(i, e = null) {
+    var s;
+    if (i === this.route && e === this.routeStep && (this.routeGroup !== null || !i)) return;
+    const n = i !== null && i === this.route && this.routeGroup !== null;
+    this.route = i, this.routeStep = e, n ? this.restyleRoute() : this.buildRoute(), (s = this.map) == null || s.triggerRepaint();
+  }
+  /** The track's texture already carries the green and the white kerb, so the material's own colour
+   *  stays white and only emphasis separates the step being walked from the rest of the path. A
+   *  route is one route: dimming the other steps says "later", where recolouring them would say
+   *  "different". */
+  routeStyle(i) {
+    return { opacity: this.routeStep === null || i === this.routeStep ? 1 : 0.5 };
+  }
+  restyleRoute() {
+    var i;
+    (i = this.routeGroup) == null || i.traverse((e) => {
+      e instanceof v.Mesh && (e.material.opacity = this.routeStyle(e.userData.step).opacity);
+    });
+  }
+  buildRoute() {
+    var w, y;
+    this.clipBoundsDirty = !0, this.rigs = this.rigs.filter((d) => d.id !== Pt), this.rigState.delete(Pt), this.routeGroup && (this.routeGroup.removeFromParent(), this.routeGroup.traverse((d) => {
+      d instanceof v.Mesh && (d.geometry.dispose(), d.material.dispose());
+    }), (w = this.routeTile) == null || w.dispose(), this.routeTile = null, this.routeGroup = null);
+    const i = this.route, e = this.project;
+    if (!i || !e) return;
+    const n = Mt(e).floors, s = n.get(this.activeFloor ?? ""), o = (d) => {
+      var S, p;
+      return !(!this.buried && d && (((S = n.get(d)) == null ? void 0 : S.elevation) ?? 0) < 0 || this.buried && (d === null || s && ((p = n.get(d ?? "")) == null ? void 0 : p.buildingId) !== s.buildingId) || !this.stack && d !== null && d !== this.activeFloor);
+    }, l = (d) => {
+      var S;
+      return d === null ? (
+        // Out of doors is grade, and a walk has moved grade — see sceneGround.
+        this.ground + Ct + 0.05
+      ) : this.present((this.stack ? ((S = n.get(d)) == null ? void 0 : S.elevation) ?? 0 : this.rebase) + q + $ + Ie + 0.07);
+    }, f = new v.Group(), r = Ve(i), m = new v.DataTexture(
+      new Uint8Array(We(this.mapStyle.routeActive ?? le).data.buffer),
+      he[0],
+      he[1],
+      v.RGBAFormat
+    );
+    m.wrapS = v.RepeatWrapping, m.colorSpace = v.SRGBColorSpace, m.generateMipmaps = !0, m.minFilter = v.LinearMipmapLinearFilter, m.magFilter = v.LinearFilter, m.anisotropy = Math.min(8, ((y = this.renderer) == null ? void 0 : y.capabilities.getMaxAnisotropy()) ?? 1), m.needsUpdate = !0;
+    const h = (d, S, p = !0) => {
+      const u = new v.Mesh(
+        d,
+        new v.MeshBasicMaterial({
+          color: p ? "#ffffff" : this.mapStyle.routeActive ?? le,
+          map: p ? m : null,
+          opacity: this.routeStyle(S).opacity,
+          transparent: !0,
+          depthWrite: !1,
+          side: v.DoubleSide
+        })
+      );
+      u.renderOrder = 10, u.raycast = () => {
+      }, u.userData.step = S, f.add(u);
+    };
+    let c = null;
+    const I = () => {
+      if (c && c.points.length > 1 && o(c.fid)) {
+        const d = this.ribbonGeometry(c.points, l(c.fid), 0.7);
+        d && h(d, c.step);
+      }
+      c = null;
+    };
+    for (let d = 0; d < i.legs.length; d++) {
+      const S = i.legs[d], p = r[d];
+      if (S.edge.kind === "stairs" || S.edge.kind === "elevator") {
+        I();
+        const [x, a] = this.xy(S.from.position);
+        if (this.stack) {
+          if (!o(S.from.floorId) && !o(S.to.floorId)) continue;
+          const L = l(S.from.floorId), F = l(S.to.floorId), D = new v.CylinderGeometry(0.14, 0.14, Math.abs(F - L) || 0.1, 10);
+          D.rotateX(Math.PI / 2), D.translate(x, a, (L + F) / 2), h(D, p, !1);
+        } else if (S.from.floorId === this.activeFloor || S.to.floorId === this.activeFloor) {
+          const L = new v.CylinderGeometry(0.8, 0.8, 0.05, 28);
+          L.rotateX(Math.PI / 2), L.translate(x, a, l(this.activeFloor) + 0.02), h(L, p, !1);
+        }
+        continue;
+      }
+      const u = S.from.floorId === S.to.floorId ? S.from.floorId : S.from.floorId ?? S.to.floorId;
+      (!c || c.step !== p || c.fid !== u) && (I(), c = { step: p, fid: u, points: [S.from.position] }), c.points.push(S.to.position);
+    }
+    if (I(), !f.children.length) {
+      m.dispose();
+      return;
+    }
+    this.routeGroup = f, this.routeTile = m, this.rig(
+      Pt,
+      f,
+      1,
+      0.55,
+      // cycles a second: one arrow-length every ~1.8 s, a walking pace rather than a barber's pole
+      (d, S) => {
+        m.offset.x = -S;
+      },
+      !0
+    ), this.scene.add(f);
+  }
+  /** Flat mitred triangle-strip ribbon at a constant z, in scene metres. */
+  ribbonGeometry(i, e, n) {
+    const s = [];
+    for (const h of i) {
+      const c = this.xy(h);
+      (!s.length || Math.hypot(c[0] - s[s.length - 1][0], c[1] - s[s.length - 1][1]) > 0.01) && s.push(c);
+    }
+    if (s.length < 2) return null;
+    const o = [], l = [], f = [];
+    let r = 0;
+    for (let h = 0; h < s.length; h++) {
+      h && (r += Math.hypot(s[h][0] - s[h - 1][0], s[h][1] - s[h - 1][1]));
+      const c = s[Math.max(0, h - 1)], I = s[Math.min(s.length - 1, h + 1)], w = I[0] - c[0], y = I[1] - c[1], d = Math.hypot(w, y) || 1;
+      let S = -y / d, p = w / d, u = n;
+      if (h > 0 && h < s.length - 1) {
+        const x = s[h][0] - s[h - 1][0], a = s[h][1] - s[h - 1][1], L = Math.hypot(x, a) || 1, F = s[h + 1][0] - s[h][0], D = s[h + 1][1] - s[h][1], nt = Math.hypot(F, D) || 1, U = -(a / L + D / nt), _ = x / L + F / nt, et = Math.hypot(U, _);
+        if (et > 1e-3) {
+          S = U / et, p = _ / et;
+          const ot = S * (-a / L) + p * (x / L);
+          u = n / Math.max(0.4, Math.abs(ot));
+        }
+      }
+      if (o.push(s[h][0] + S * u, s[h][1] + p * u, e, s[h][0] - S * u, s[h][1] - p * u, e), l.push(r / ce, 0, r / ce, 1), h) {
+        const x = h * 2;
+        f.push(x - 2, x - 1, x, x - 1, x + 1, x);
+      }
+    }
+    const m = new v.BufferGeometry();
+    return m.setAttribute("position", new v.Float32BufferAttribute(o, 3)), m.setAttribute("uv", new v.Float32BufferAttribute(l, 2)), m.setIndex(f), m;
+  }
+  // Grows the building out of the map when entering 3D so the mode switch reads as one motion.
+  animateIn() {
+    var i;
+    this.growth = 0, this.growthStart = performance.now(), (i = this.map) == null || i.triggerRepaint();
+  }
+  refreshHighlight() {
+    var i;
+    for (const e of [...this.highlight.children]) {
+      const n = e;
+      n.geometry.dispose(), n.material.dispose();
+    }
+    this.highlight.clear();
+    for (const [e, n] of [
+      [this.hovered, this.mapStyle.hover ?? "#8d85dc"],
+      [this.selected, this.mapStyle.selection ?? "#6355d4"]
+    ])
+      if (e) {
+        const s = this.batch.outline(e, n);
+        s && this.highlight.add(s);
+      }
+    (i = this.map) == null || i.triggerRepaint();
+  }
+  setHover(i) {
+    i !== this.hovered && (this.hovered = i, this.refreshHighlight());
+  }
+  get diagnostics() {
+    var i, e, n;
+    return {
+      revision: this.revision,
+      drawCalls: ((i = this.renderer) == null ? void 0 : i.info.render.calls) ?? 0,
+      geometries: ((e = this.renderer) == null ? void 0 : e.info.memory.geometries) ?? 0,
+      textures: ((n = this.renderer) == null ? void 0 : n.info.memory.textures) ?? 0,
+      animatedWater: this.hasWater
+    };
+  }
+  render(i, e) {
+    var m, h, c, I, w, y;
+    if (!this.renderer) return;
+    i.clear(i.DEPTH_BUFFER_BIT);
+    const n = performance.now();
+    this.hasWater && (this.waterTime.value = n / 1e3, this.paintSoon());
+    const s = Math.min(0.1, this.lastFrame ? (n - this.lastFrame) / 1e3 : 0);
+    this.lastFrame = n, this.rigs.length && this.animate(s) && (this.shadowsMoved && this.refreshShadows(), this.shadowsMoved ? (m = this.map) == null || m.triggerRepaint() : this.paintSoon()), this.growth < 1 ? (this.growth = Math.min(1, (performance.now() - this.growthStart) / 550), this.scene.scale.z = 0.03 + 0.97 * (1 - (1 - this.growth) ** 3), this.refreshShadows(), (h = this.map) == null || h.triggerRepaint()) : this.scene.scale.z = 1;
+    const o = (I = (c = this.map) == null ? void 0 : c.transform) == null ? void 0 : I.mercatorMatrix;
+    this.worldToClip.fromArray((o == null ? void 0 : o.length) === 16 ? o : e.defaultProjectionData.mainMatrix).multiply(this.transform);
+    const l = this.walking ? li(this.worldToClip, e.nearZ, e.farZ) : e.nearZ;
+    if (this.buried && (this.clipBoundsDirty && (this.scene.updateMatrixWorld(!0), this.clipBounds.setFromObject(this.scene).applyMatrix4(new v.Matrix4().copy(this.scene.matrixWorld).invert()), this.clipBoundsDirty = !1), hi(this.worldToClip, this.clipBounds, this.scene.scale.z, l, e.farZ)), this.clipToWorld.copy(this.worldToClip).invert(), ci(this.camera, this.worldToClip, this.clipToWorld), this.passenger) {
+      const d = new v.Vector3(0, 0, 0).applyMatrix4(this.clipToWorld).sub(this.camera.position).normalize();
+      this.passenger.update(this.camera.position, d, n / 1e3, s) && this.paintSoon(), this.passenger.updateMatrixWorld(!0);
+    }
+    if (this.fixtureLights) {
+      const { shadowsChanged: d, animate: S } = this.fixtureLights.update(this.camera.position, n / 1e3);
+      d && (this.renderer.shadowMap.needsUpdate = !0), S && this.paintSoon();
+    }
+    const f = (w = this.map) == null ? void 0 : w.getCanvas();
+    f && this.renderer.setViewport(0, 0, f.width, f.height);
+    const r = f ? `${f.clientWidth}:${f.clientHeight}` : "";
+    (!this.previousProjection.equals(this.worldToClip) || this.previousScale !== this.scene.scale.z || this.previousSize !== r) && (this.markerCache.clear(), this.previousProjection.copy(this.worldToClip), this.previousScale = this.scene.scale.z, this.previousSize = r), this.cage.setBearing(((y = this.map) == null ? void 0 : y.getBearing()) ?? 0), this.renderer.resetState(), this.buried && (this.renderer.state.buffers.depth.setMask(!0), this.renderer.state.buffers.depth.setClear(1), this.renderer.clearDepth()), this.renderer.transmissionResolutionScale = this.hasWater ? 0.5 : 1, this.renderer.render(this.scene, this.camera), this.renderer.resetState();
+  }
+  /** Where a point on a floor's walking surface lands on screen — the avatar marker, which is not an
+   *  object and has no occlusion to test. `visible` is the frustum only. */
+  projectPoint(i, e) {
+    var o;
+    if (!this.project || !this.map) return null;
+    const n = (this.stack ? ((o = Mt(this.project).floors.get(e ?? "")) == null ? void 0 : o.elevation) ?? 0 : e ? this.rebase : 0) + Q(e), s = new v.Vector3(...this.xy(i), this.present(n) * this.scene.scale.z).applyMatrix4(this.worldToClip);
+    return {
+      x: (s.x + 1) / 2 * this.map.getCanvas().clientWidth,
+      y: (1 - s.y) / 2 * this.map.getCanvas().clientHeight,
+      visible: Math.abs(s.x) <= 1.05 && Math.abs(s.y) <= 1.05 && s.z < 1 && s.z > -1
+    };
+  }
+  projectObject(i) {
+    var m;
+    if (!this.project || !this.map) return null;
+    const e = this.markerCache.get(i.id);
+    if (e) return e;
+    const n = this.xy(fe(this.project, i)), s = (this.stack ? ((m = Mt(this.project).floors.get(i.floorId ?? "")) == null ? void 0 : m.elevation) ?? 0 : i.floorId ? this.rebase : 0) + Q(i.floorId) + (i.kind === "camera" ? i.height : 0.5), o = new v.Vector3(...n, this.present(s) * this.scene.scale.z), l = o.clone().applyMatrix4(this.worldToClip);
+    let f = Math.abs(l.x) <= 1.05 && Math.abs(l.y) <= 1.05 && l.z < 1 && l.z > -1 && (!this.walking || this.camera.position.distanceTo(o) <= 12) && (!this.buried || i.floorId !== null) && (!this.stack || i.floorId === null || i.floorId === this.activeFloor);
+    if (f && (this.stack || this.walking)) {
+      const h = !this.map.isMoving(), c = this.occlusionCache.get(i.id);
+      if (!this.walking && !h && c !== void 0) f = c;
+      else {
+        const I = new v.Vector3(l.x, l.y, -1).applyMatrix4(this.clipToWorld), w = I.distanceTo(o), y = (this.present(s) - this.present(s - 0.25)) * this.scene.scale.z, d = new v.Raycaster(I, o.clone().sub(I).normalize(), 0, Math.max(0, w - y));
+        d.layers.enableAll(), f = !d.intersectObjects(this.pickables, !1).some((S) => S.object instanceof v.Mesh && ve(S) !== i.id), this.occlusionCache.set(i.id, f);
+      }
+    }
+    const r = {
+      x: (l.x + 1) / 2 * this.map.getCanvas().clientWidth,
+      y: (1 - l.y) / 2 * this.map.getCanvas().clientHeight,
+      visible: f
+    };
+    return this.markerCache.set(i.id, r), r;
+  }
+  pick(i) {
+    if (!this.map) return null;
+    const e = i.x / this.map.getCanvas().clientWidth * 2 - 1, n = 1 - i.y / this.map.getCanvas().clientHeight * 2, s = new v.Vector3(e, n, -1).applyMatrix4(this.clipToWorld), o = new v.Vector3(e, n, 1).applyMatrix4(this.clipToWorld), l = new v.Raycaster(s, o.sub(s).normalize());
+    return l.layers.enableAll(), l.intersectObjects(this.pickables, !1).map(ve).find(Boolean) ?? null;
+  }
+  disposeScene() {
+    var n;
+    this.hasWater = !1, this.passenger = void 0, this.fixtureLights = void 0, this.cage.dispose(), this.markerCache.clear(), this.occlusionCache.clear(), this.pickables = [], this.clipBoundsDirty = !0;
+    const i = /* @__PURE__ */ new Set(), e = /* @__PURE__ */ new Set();
+    this.scene.traverse((s) => {
+      var o;
+      s instanceof ki && s.getRenderTarget().dispose(), (s instanceof v.Mesh || s instanceof v.LineSegments) && (i.add(s.geometry), (Array.isArray(s.material) ? s.material : [s.material]).forEach((l) => {
+        var f;
+        l.userData.shared || e.add(l), l.userData.ownedMap && ((f = l.map) == null || f.dispose());
+      }), s instanceof v.InstancedMesh && s.dispose()), s instanceof v.Light && "shadow" in s && ((o = s.shadow) == null || o.dispose());
+    }), i.forEach((s) => s.dispose()), e.forEach((s) => s.dispose()), this.scene.clear(), this.highlight.clear(), this.batch.clear(), (n = this.routeTile) == null || n.dispose(), this.routeTile = null, this.routeGroup = null;
+  }
+  onRemove() {
+    var i, e, n;
+    clearTimeout(this.loopTimer), this.loopTimer = void 0, this.disposeScene(), this.materials.dispose(), (i = this.cabinMaterials) == null || i.dispose(), this.cabinMaterials = void 0, this.envCache.forEach((s) => s.dispose()), this.envCache.clear(), (e = this.renderer) == null || e.resetState(), (n = this.renderer) == null || n.dispose(), this.renderer = void 0, this.map = void 0;
+  }
+}
+export {
+  q as LIFT,
+  $ as SLAB,
+  Ts as SceneLayer,
+  Me as nestingLift,
+  gi as rampJoins,
+  ke as rampVoids,
+  $i as sceneElevation,
+  Wi as sceneGround,
+  Le as shellPlate,
+  Ce as walkCeiling,
+  Lt as walkSoffit
+};
+//# sourceMappingURL=SceneLayer.js.map