@ifc-lite/renderer 1.43.0 → 1.44.1

package/dist/camera-guards.js

@@ -0,0 +1,150 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Smallest orthographic half-height the projection matrix is ever built from.
+ * Matches the floor the orthographic zoom clamps to in `CameraControls`.
+ */
+export const MIN_ORTHO_SIZE = 0.01;
+/** Default orthographic half-height, in world units, and the neutral fallback. */
+export const DEFAULT_ORTHO_SIZE = 50;
+/**
+ * Is `dist` a usable camera-to-target radius — finite, and at least `min` away
+ * from zero so dividing by it means something?
+ *
+ * The navigation gestures all opened with a bare `dist < eps` early return.
+ * That is a magnitude test, not a finiteness test, so a malformed pose walked
+ * straight past it (#2441). Past the guard, the gesture writes its result into
+ * `camera.position` *and* `camera.target`, so a single non-finite coordinate
+ * (a BCF viewpoint restored from a file reaches the public setters
+ * unvalidated) spreads across all six on the first drag.
+ *
+ * Callers keep their own fallback: there is no single substitute distance that
+ * is right for all of them, which is also why `Camera.getDistance()` reports
+ * the pose verbatim rather than sanitizing it centrally.
+ */
+export function isUsableDistance(dist, min) {
+    return Number.isFinite(dist) && dist >= min;
+}
+/**
+ * Is `up` a usable screen-up reference — every component finite?
+ *
+ * `up` is the third vector of the pose, and it reaches the camera exactly the
+ * way `position` and `target` do: BCF stores `CameraUpVector`, `bcfToViewerCoords`
+ * only swaps axes, and `applyViewpoint` writes the result straight through
+ * (`animateToWithUp` on the animated path — which bypasses `setUp` entirely —
+ * or `setUp` on the instant one).
+ *
+ * Finiteness only, deliberately no magnitude floor. `normalize` already absorbs
+ * a zero-length or degenerate `up` by returning `{0,0,0}`, and a *short* `up` is
+ * a valid input whose direction is perfectly well defined — `MathUtils.lookAt`
+ * documents the same thing and keys its own degeneracy test on the angle rather
+ * than a length for exactly this reason. A floor here would silently drop the
+ * cursor anchor for poses that navigate correctly today.
+ *
+ * The floor `normalize` used to have was a *lower* bound, which is what left
+ * the gap: `len > 1e-10` is false for NaN (so a NaN `up` degraded safely to
+ * the zero vector) but **true for Infinity**, and scaling infinite components
+ * by `1 / Infinity` is `Infinity * 0` — NaN. Measured, not reasoned: `up`
+ * `(Infinity, 1, 0)` on a finite pose came back from one cursor-anchored zoom
+ * with position AND target `(NaN, NaN, NaN)`, in both projection modes (#2441).
+ * Both copies of `normalize` now key that floor on `Number.isFinite` too
+ * (#2479), so an unusable `up` reaches the same zero vector by either route —
+ * this predicate says so at the top of the gesture rather than relying on a
+ * helper's degradation three lines in, and it is what stops the *pose* being
+ * rewritten from a basis that carries no orientation.
+ *
+ * As with {@link isUsableDistance}, the caller keeps its own fallback and the
+ * pose is left exactly as it was found — `getUp()` still reports the malformed
+ * vector, so a restored viewpoint is not silently rewritten on its way back out.
+ */
+export function isUsableUp(up) {
+    return Number.isFinite(up.x) && Number.isFinite(up.y) && Number.isFinite(up.z);
+}
+/**
+ * Clamp an orthographic half-height, rejecting a non-finite one.
+ *
+ * `Math.max`/`Math.min` are NaN-transparent, so a clamp alone does not stop a
+ * malformed value reaching the projection matrix (#2441). Returns `null` when
+ * there is no usable size, so the caller can keep the value it already had
+ * rather than substitute an arbitrary one.
+ *
+ * The `Infinity` rejection is not theoretical: `orthoSize` is scaled in place
+ * by the orthographic zoom, so a legitimately huge but finite half-height
+ * overflows to `Infinity` after enough zoom-out notches, and
+ * `Math.max(MIN_ORTHO_SIZE, Infinity)` is `Infinity`.
+ */
+export function usableOrthoSize(size) {
+    return Number.isFinite(size) ? Math.max(MIN_ORTHO_SIZE, size) : null;
+}
+/**
+ * Are all of `values` finite?
+ *
+ * The gesture *arguments* — wheel deltas, pointer deltas, walk axes — are a
+ * different input class from the pose the gestures already guard (#2473), and
+ * they reach the same arithmetic. Measured on the pre-guard code: `orbit(NaN,
+ * 0)`, `pan(NaN, 0)`, `zoom(NaN)` and `moveFirstPerson(NaN, 0, 0)` each turned
+ * a perfectly finite pose into a non-finite one in a single call, and
+ * `orbit(Infinity, 0)` / `pan(Infinity, 0)` / `moveFirstPerson(Infinity, 0, 0)`
+ * did the same — the two do **not** behave alike everywhere, so both must be
+ * tested. (`zoom` is the exception: its delta is clamped by
+ * `Math.min(|delta| * s, MAX_ZOOM_DELTA)`, which absorbs `Infinity` but not
+ * `NaN`.)
+ */
+export function areFiniteNumbers(...values) {
+    for (const v of values) {
+        if (!Number.isFinite(v))
+            return false;
+    }
+    return true;
+}
+/**
+ * Is this a usable cursor anchor — a finite cursor position inside a viewport
+ * with a real extent?
+ *
+ * The cursor-anchored zoom divides by the canvas dimensions, so they need
+ * `> 0` and not merely "truthy". Truthiness already rejects `0` and `NaN`
+ * (both falsy) which is why a collapsed canvas never reached the division, but
+ * it accepts `Infinity` and a negative width — the latter mirrors the anchor
+ * and drifts the target the wrong way. `Number.isFinite(w) && w > 0` is the
+ * check that means what the division needs.
+ */
+export function isUsableCursorAnchor(cursorX, cursorY, viewportWidth, viewportHeight) {
+    return (areFiniteNumbers(cursorX, cursorY, viewportWidth, viewportHeight) &&
+        viewportWidth > 0 &&
+        viewportHeight > 0);
+}
+/**
+ * Is this AABB something the camera can be fitted to?
+ *
+ * Two rejections, and they are different failures:
+ *
+ *  - **Non-finite corners.** Fitting computes `center = (min + max) / 2` and
+ *    `size = max - min`, and writes both into the pose. `Math.max` picking the
+ *    largest extent is NaN-transparent, so one bad coordinate reaches
+ *    `camera.position`, `camera.target` *and* (in orthographic mode)
+ *    `orthoSize`, which `getOrthoSize()` then hands to a saved viewpoint —
+ *    persisting the damage past the session (#2461).
+ *  - **An inverted box** (`max < min` on any axis). That is the empty-AABB
+ *    sentinel every accumulator in this package starts from (`min = +Infinity,
+ *    max = -Infinity`) leaking out as if it were a real box, which is what a
+ *    mesh with no finite vertices produces. Its centre is `NaN` and its size
+ *    is negative; there is nothing to frame.
+ *
+ * A *degenerate* box (`max === min` on some or all axes — a flat wall, a
+ * single point) is explicitly **not** rejected: it is a legitimate thing to
+ * frame and `frameBounds` already centres on it.
+ *
+ * The answer to an unusable box is to reject the fit and leave the pose alone,
+ * not to clamp: there is no meaningful substitute for an infinite or inverted
+ * extent, and no previous bounds to fall back to at these entry points, which
+ * are stateless. Keeping the pose the user already had is the same policy
+ * `setAspect`, `setFOV` and `setOrthoSize` settled on (#2441/#2450).
+ */
+export function isUsableBounds(min, max) {
+    return (areFiniteNumbers(min.x, min.y, min.z, max.x, max.y, max.z) &&
+        max.x >= min.x &&
+        max.y >= min.y &&
+        max.z >= min.z);
+}
+//# sourceMappingURL=camera-guards.js.map

package/dist/camera-guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-guards.js","sourceRoot":"","sources":["../src/camera-guards.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AA0B/D;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,CAAC;AAEnC,kFAAkF;AAClF,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,CAAC;AAErC;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY,EAAE,GAAW;IACxD,OAAO,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,GAAG,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,UAAU,CAAC,EAAQ;IACjC,OAAO,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACjF,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,OAAO,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACvE,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAG,MAAgB;IAClD,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YAAE,OAAO,KAAK,CAAC;IACxC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,oBAAoB,CAClC,OAAe,EACf,OAAe,EACf,aAAqB,EACrB,cAAsB;IAEtB,OAAO,CACL,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,cAAc,CAAC;QACjE,aAAa,GAAG,CAAC;QACjB,cAAc,GAAG,CAAC,CACnB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,cAAc,CAAC,GAAS,EAAE,GAAS;IACjD,OAAO,CACL,gBAAgB,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;QAC1D,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;QACd,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;QACd,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CACf,CAAC;AACJ,CAAC"}

package/dist/camera-matrices.d.ts

@@ -0,0 +1,14 @@
+import type { CameraInternalState } from './camera-state.js';
+export declare function updateCameraMatrices(state: CameraInternalState): void;
+/**
+ * Compute tight near/far for orthographic mode by projecting the scene
+ * bounding sphere onto the camera view direction.
+ *
+ * This gives optimal depth precision (minimizing z-fighting) while ensuring
+ * no geometry is clipped regardless of camera position or view angle.
+ */
+export declare function computeOrthoNearFar(state: CameraInternalState, distance: number): {
+    near: number;
+    far: number;
+};
+//# sourceMappingURL=camera-matrices.d.ts.map

package/dist/camera-matrices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-matrices.d.ts","sourceRoot":"","sources":["../src/camera-matrices.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAG7D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI,CA4DrE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,mBAAmB,EAC1B,QAAQ,EAAE,MAAM,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAyE/B"}

package/dist/camera-matrices.js

@@ -0,0 +1,146 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * View / projection / view-projection matrix derivation.
+ *
+ * One subject: camera state in, three finite matrices out. Its failure story
+ * is the #2441 near/far backstops — a non-finite pose or `orthoSize` must not
+ * reach the projection matrix, because `MathUtils.lookAt` scrubs the *view*
+ * matrix but nothing scrubs the projection one, and a NaN there leaves the
+ * viewport dead while every other reading looks healthy.
+ *
+ * **Hot path.** `updateCameraMatrices` runs on every frame the camera moves.
+ * It takes the shared state object **by reference** and nothing else: do not
+ * destructure it into parameters (that allocates an arguments object per
+ * frame) and do not widen the parameter to a structural supertype (that
+ * invites megamorphic dispatch). The allocation profile is deliberately
+ * unchanged from the method this replaced — `lookAt`, `perspectiveReverseZ` /
+ * `orthographicReverseZ` and `multiply` each already return a fresh `Mat4`,
+ * and the ortho branch already returned a fresh `{near, far}` per frame.
+ */
+import { MathUtils } from './math.js';
+import { DEFAULT_ORTHO_SIZE, usableOrthoSize } from './camera-guards.js';
+export function updateCameraMatrices(state) {
+    const dx = state.camera.position.x - state.camera.target.x;
+    const dy = state.camera.position.y - state.camera.target.y;
+    const dz = state.camera.position.z - state.camera.target.z;
+    const rawDistance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    // A non-finite position or target — a malformed BCF viewpoint reaches the
+    // public setters unvalidated — would put NaN into near/far and from there
+    // into the projection matrix, leaving the viewport dead even though
+    // `MathUtils.lookAt` scrubs the view matrix (#2441). Fall back to a
+    // neutral distance so the projection stays finite; the camera state itself
+    // is left as the caller set it.
+    const distance = Number.isFinite(rawDistance) ? rawDistance : 1;
+    state.viewMatrix = MathUtils.lookAt(state.camera.position, state.camera.target, state.camera.up);
+    if (state.projectionMode === 'orthographic') {
+        // Orthographic: project scene bounding sphere onto view direction for tight near/far.
+        // Tight range maximizes depth precision (less z-fighting) and prevents clipping.
+        const nf = computeOrthoNearFar(state, distance);
+        state.camera.near = nf.near;
+        state.camera.far = nf.far;
+        // Backstop for the writers that never see `setOrthoSize`'s clamp: the
+        // orthographic zoom scales `orthoSize` in place and the animator
+        // interpolates it, so a NaN reaching either (from a malformed pose, or
+        // from bounds that were themselves non-finite) would land straight in
+        // the projection matrix. Same fallback shape as the distance above.
+        //
+        // Finiteness alone is not the whole backstop: `Number.isFinite(0)` is
+        // true, and a zero — or negative — half-height makes `right - left` and
+        // `top - bottom` zero, so `orthographicReverseZ` divides by zero and the
+        // matrix comes back with `Infinity` scale terms. That is the same dead
+        // viewport as a NaN, reached through a *valid-but-falsy* value rather
+        // than an exotic one. `usableOrthoSize` is the single predicate that says
+        // both things at once, and it is the same one every writer already goes
+        // through — so this backstop now enforces exactly the invariant the
+        // writers promise rather than half of it (#2441).
+        const h = usableOrthoSize(state.orthoSize) ?? DEFAULT_ORTHO_SIZE;
+        const w = h * state.camera.aspect;
+        state.projMatrix = MathUtils.orthographicReverseZ(-w, w, -h, h, state.camera.near, state.camera.far);
+    }
+    else {
+        // Perspective: adapt near/far based on camera-to-target distance
+        state.camera.near = Math.max(0.01, distance * 0.001);
+        state.camera.far = Math.max(distance * 10, 1000);
+        state.projMatrix = MathUtils.perspectiveReverseZ(state.camera.fov, state.camera.aspect, state.camera.near, state.camera.far);
+    }
+    state.viewProjMatrix = MathUtils.multiply(state.projMatrix, state.viewMatrix);
+}
+/**
+ * Compute tight near/far for orthographic mode by projecting the scene
+ * bounding sphere onto the camera view direction.
+ *
+ * This gives optimal depth precision (minimizing z-fighting) while ensuring
+ * no geometry is clipped regardless of camera position or view angle.
+ */
+export function computeOrthoNearFar(state, distance) {
+    const bounds = state.sceneBounds;
+    if (!bounds) {
+        // Fallback: generous range centered on camera
+        return { near: -Math.max(distance, 500), far: Math.max(distance, 500) };
+    }
+    // Scene bounding sphere center and radius
+    const cx = (bounds.min.x + bounds.max.x) / 2;
+    const cy = (bounds.min.y + bounds.max.y) / 2;
+    const cz = (bounds.min.z + bounds.max.z) / 2;
+    const ex = bounds.max.x - bounds.min.x;
+    const ey = bounds.max.y - bounds.min.y;
+    const ez = bounds.max.z - bounds.min.z;
+    const radius = Math.sqrt(ex * ex + ey * ey + ez * ez) / 2;
+    // View direction (camera looks from position toward target)
+    const pos = state.camera.position;
+    let vx = state.camera.target.x - pos.x;
+    let vy = state.camera.target.y - pos.y;
+    let vz = state.camera.target.z - pos.z;
+    const vLen = Math.sqrt(vx * vx + vy * vy + vz * vz);
+    // Add 10% padding for safety.
+    const pad = radius * 0.1 + 1;
+    let near;
+    let far;
+    if (Number.isFinite(vLen) && vLen > 1e-8) {
+        vx /= vLen;
+        vy /= vLen;
+        vz /= vLen;
+        // Signed distance from camera to scene center along view direction
+        const toCenter = (cx - pos.x) * vx + (cy - pos.y) * vy + (cz - pos.z) * vz;
+        // Near/far as distances from camera along view direction.
+        // The sphere spans [toCenter - radius, toCenter + radius] along view dir.
+        near = toCenter - radius - pad;
+        far = toCenter + radius + pad;
+    }
+    else {
+        // No view direction to project onto — position and target coincide, or
+        // the pose is non-finite. Skipping the normalization (which is what the
+        // bare `vLen > 1e-8` did) left `v` at its raw near-zero value, so
+        // `toCenter` collapsed to ~0 and the range came out centred on the
+        // *camera* rather than on the scene: a camera parked 1000 units away got
+        // `[-(r + pad), +(r + pad)]` and clipped the entire model away, which is
+        // a blank viewport reached through a range that is perfectly finite and
+        // therefore sails past the non-finite backstop below.
+        //
+        // There is no honest direction to substitute either: `MathUtils.lookAt`
+        // picks its own fallback basis for a degenerate pose, and any axis chosen
+        // here could disagree with the one the frame is actually drawn from.
+        // Bracket the whole bounding sphere symmetrically instead — that contains
+        // the scene whichever way `lookAt` ended up looking.
+        const span = Math.sqrt((cx - pos.x) * (cx - pos.x) +
+            (cy - pos.y) * (cy - pos.y) +
+            (cz - pos.z) * (cz - pos.z)) + radius + pad;
+        near = -span;
+        far = span;
+    }
+    // Ensure minimum range for depth precision
+    if (far - near < 1) {
+        near -= 0.5;
+        far += 0.5;
+    }
+    // Same contract as the perspective branch: a non-finite camera position or
+    // scene bound must not reach the projection matrix (#2441).
+    if (!Number.isFinite(near) || !Number.isFinite(far)) {
+        const fallback = Math.max(Number.isFinite(distance) ? distance : 0, 500);
+        return { near: -fallback, far: fallback };
+    }
+    return { near, far };
+}
+//# sourceMappingURL=camera-matrices.js.map

package/dist/camera-matrices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-matrices.js","sourceRoot":"","sources":["../src/camera-matrices.ts"],"names":[],"mappings":"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"}

package/dist/camera-preset-view.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Preset views: the ViewCube's six named directions, plus the admission check
+ * that decides whether a preset may be applied at all.
+ *
+ * Split out of `camera-framing.ts`, which owns the *free* framing pickers
+ * (point / bounds / extents — "put the camera on this thing, keeping the
+ * current direction"). Presets are the opposite subject: the direction is
+ * dictated by the named face and the caller's rotation cycle, and the box is
+ * whatever the caller supplied or whatever the current pose implies. The two
+ * share only box arithmetic, which is why this module imports `centerOf` /
+ * `maxExtentOf` rather than owning a second copy.
+ *
+ * Pure by construction, exactly as `camera-framing.ts` is: everything here
+ * reads `CameraInternalState` and returns a target, nothing writes to it or
+ * touches the tween. That is what keeps both modules free of a cycle back into
+ * `camera-animation.ts`, which is the one that applies the results.
+ *
+ * **Guard placement.** `resolvePresetBounds` validates the box exactly once,
+ * here, and a rejection is `null`. Callers null-check and do nothing else: a
+ * second, defensive copy of the same guard in the caller would mean neither
+ * copy is load-bearing on its own, and the mutation test that pins this guard
+ * would go quiet while still looking green.
+ */
+import type { Vec3 } from './types.js';
+import type { CameraInternalState } from './camera-state.js';
+import { type FramingBounds } from './camera-framing.js';
+/**
+ * Get current bounds estimate (simplified - in production would use scene bounds).
+ */
+export declare function estimateBoundsFromPose(state: CameraInternalState): FramingBounds;
+/**
+ * Resolve the box a preset view should fit, from the caller's bounds or the
+ * current pose, and reject it if it is not usable.
+ *
+ * This is the whole admission decision for `setPresetView`, deliberately kept
+ * ahead of the rotation-cycling counter: a rejected preset must not advance
+ * the cycle, and the caller can only honour that if the verdict arrives before
+ * it mutates anything.
+ */
+export declare function resolvePresetBounds(state: CameraInternalState, bounds?: FramingBounds): FramingBounds | null;
+/**
+ * Pose for a preset view (Y-up coordinate system).
+ *
+ * `bounds` must already have passed {@link resolvePresetBounds}; `rotation` is
+ * the caller's 0-3 cycle position, which is why this takes it rather than
+ * owning it — the counter belongs to the animator, which is what remembers
+ * that the same face was clicked twice.
+ *
+ * @param buildingRotation Optional building rotation in radians (from IfcSite placement)
+ */
+export declare function presetViewTarget(state: CameraInternalState, view: 'top' | 'bottom' | 'front' | 'back' | 'left' | 'right', bounds: FramingBounds, rotation: number, buildingRotation?: number): {
+    position: Vec3;
+    target: Vec3;
+    up: Vec3;
+};
+//# sourceMappingURL=camera-preset-view.d.ts.map

package/dist/camera-preset-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-preset-view.d.ts","sourceRoot":"","sources":["../src/camera-preset-view.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,EAAyC,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEhG;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,mBAAmB,GAAG,aAAa,CAsBhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,mBAAmB,EAC1B,MAAM,CAAC,EAAE,aAAa,GACrB,aAAa,GAAG,IAAI,CAYtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,mBAAmB,EAC1B,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EAC5D,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,CAAC,EAAE,MAAM,GACxB;IAAE,QAAQ,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,IAAI,CAAC;IAAC,EAAE,EAAE,IAAI,CAAA;CAAE,CA0H5C"}

package/dist/camera-preset-view.js

@@ -0,0 +1,180 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+import { isUsableBounds } from './camera-guards.js';
+import { centerOf, fitDistanceFor, maxExtentOf } from './camera-framing.js';
+/**
+ * Get current bounds estimate (simplified - in production would use scene bounds).
+ */
+export function estimateBoundsFromPose(state) {
+    // Estimate bounds from camera distance
+    const dir = {
+        x: state.camera.position.x - state.camera.target.x,
+        y: state.camera.position.y - state.camera.target.y,
+        z: state.camera.position.z - state.camera.target.z,
+    };
+    const distance = Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
+    const size = distance / 2;
+    return {
+        min: {
+            x: state.camera.target.x - size,
+            y: state.camera.target.y - size,
+            z: state.camera.target.z - size,
+        },
+        max: {
+            x: state.camera.target.x + size,
+            y: state.camera.target.y + size,
+            z: state.camera.target.z + size,
+        },
+    };
+}
+/**
+ * Resolve the box a preset view should fit, from the caller's bounds or the
+ * current pose, and reject it if it is not usable.
+ *
+ * This is the whole admission decision for `setPresetView`, deliberately kept
+ * ahead of the rotation-cycling counter: a rejected preset must not advance
+ * the cycle, and the caller can only honour that if the verdict arrives before
+ * it mutates anything.
+ */
+export function resolvePresetBounds(state, bounds) {
+    const useBounds = bounds || estimateBoundsFromPose(state);
+    // Both sources need the check, not just the caller's: the pose-derived
+    // estimate above starts from the live pose, so a pose that is already
+    // malformed produces a malformed box and the ViewCube would then bake it in
+    // permanently. Rejecting leaves the preset un-applied, which keeps a
+    // recoverable pose recoverable (#2461).
+    if (!isUsableBounds(useBounds.min, useBounds.max)) {
+        console.warn('[Camera] Non-finite bounds for setPresetView; keeping current view');
+        return null;
+    }
+    return useBounds;
+}
+/**
+ * Pose for a preset view (Y-up coordinate system).
+ *
+ * `bounds` must already have passed {@link resolvePresetBounds}; `rotation` is
+ * the caller's 0-3 cycle position, which is why this takes it rather than
+ * owning it — the counter belongs to the animator, which is what remembers
+ * that the same face was clicked twice.
+ *
+ * @param buildingRotation Optional building rotation in radians (from IfcSite placement)
+ */
+export function presetViewTarget(state, view, bounds, rotation, buildingRotation) {
+    const center = centerOf(bounds.min, bounds.max);
+    const maxSize = maxExtentOf(bounds.min, bounds.max);
+    // Calculate distance based on FOV for proper fit. Aspect-aware: on a
+    // portrait viewport the horizontal field is the narrower one, and a preset
+    // fitted to the vertical field alone overflows it. See `fitDistanceFor`.
+    const distance = fitDistanceFor(state, maxSize, 1.5); // 1.5x for padding
+    let endPos;
+    const endTarget = center;
+    // WebGL uses Y-up coordinate system internally
+    // We set both position AND up vector for proper orthogonal views
+    let upVector = { x: 0, y: 1, z: 0 }; // Default Y-up
+    // Apply building rotation if present (rotate around Y axis).
+    //
+    // Normalized rather than trusted: this is the IfcSite placement angle,
+    // derived from the file and threaded through `Camera.setPresetView` — the
+    // published entry point — without ever meeting a guard. `Math.cos(NaN)` is
+    // NaN, and the four horizontal presets multiply it straight into `endPos`,
+    // so a malformed placement would send the ViewCube to a non-finite pose. A
+    // zero rotation is the same answer as "no rotation supplied", which is what
+    // the undefined case already resolves to.
+    const rotationRadians = Number.isFinite(buildingRotation) ? buildingRotation : 0;
+    const cosR = rotationRadians !== 0 ? Math.cos(rotationRadians) : 1.0;
+    const sinR = rotationRadians !== 0 ? Math.sin(rotationRadians) : 0.0;
+    switch (view) {
+        case 'top': {
+            // Top view: position camera *just barely* off the +Y pole so the
+            // subsequent orbit math has a well-defined polar tangent (no pole
+            // singularity). camera.up stays world Y throughout — screen-up is
+            // then determined by lookAt projecting (0,1,0) onto perp(look),
+            // which falls along the horizontal component of `-look`.
+            //
+            // The 4 rotation cycles select which compass direction appears at
+            // the top of the screen by varying the small horizontal offset
+            // (theta in the spherical math).
+            //   rotation 0 → camera slightly to +Z of center → screen-up = +Z
+            //   rotation 1 → camera slightly to +X → screen-up = +X
+            //   rotation 2 → camera slightly to -Z → screen-up = -Z
+            //   rotation 3 → camera slightly to -X → screen-up = -X
+            // Building rotation is applied as the same Y-axis rotation that
+            // setPresetView would have used to remap the legacy up vector.
+            const poleOffset = Math.sin(0.01) * distance; // ~0.6° tilt
+            const verticalOffset = Math.cos(0.01) * distance;
+            // `?? 0`: `rotation` is the animator's 0-3 cycle counter today, but it
+            // is a plain `number` on the signature, and an out-of-range, fractional
+            // or non-finite one indexes past the table and makes `thetaWorld` — and
+            // with it the whole preset pose — NaN.
+            const thetaPerRotation = [0, Math.PI / 2, Math.PI, -Math.PI / 2];
+            const thetaWorld = (thetaPerRotation[rotation] ?? 0) + rotationRadians;
+            endPos = {
+                x: center.x + poleOffset * Math.sin(thetaWorld),
+                y: center.y + verticalOffset,
+                z: center.z + poleOffset * Math.cos(thetaWorld),
+            };
+            upVector = { x: 0, y: 1, z: 0 };
+            break;
+        }
+        case 'bottom': {
+            // Bottom view: mirror of top — phi = π − MIN_PHI.
+            const poleOffset = Math.sin(0.01) * distance;
+            const verticalOffset = Math.cos(0.01) * distance;
+            const thetaPerRotation = [Math.PI, Math.PI / 2, 0, -Math.PI / 2];
+            const thetaWorld = (thetaPerRotation[rotation] ?? 0) + rotationRadians;
+            endPos = {
+                x: center.x + poleOffset * Math.sin(thetaWorld),
+                y: center.y - verticalOffset,
+                z: center.z + poleOffset * Math.cos(thetaWorld),
+            };
+            upVector = { x: 0, y: 1, z: 0 };
+            break;
+        }
+        case 'front':
+            // Front view: from +Z looking at model
+            // Rotate camera position around Y axis by building rotation
+            // Standard rotation: x' = x*cos - z*sin, z' = x*sin + z*cos
+            // For +Z direction (0,0,1): x' = -sin, z' = cos
+            // But we need to look at building's front, so use negative rotation
+            endPos = {
+                x: center.x + sinR * distance,
+                y: center.y,
+                z: center.z + cosR * distance,
+            };
+            upVector = { x: 0, y: 1, z: 0 }; // Y-up
+            break;
+        case 'back':
+            // Back view: from -Z looking at model
+            // For -Z direction (0,0,-1) rotated: x' = sin, z' = -cos
+            endPos = {
+                x: center.x - sinR * distance,
+                y: center.y,
+                z: center.z - cosR * distance,
+            };
+            upVector = { x: 0, y: 1, z: 0 }; // Y-up
+            break;
+        case 'left':
+            // Left view: from -X looking at model
+            // For -X direction (-1,0,0) rotated: x' = -cos, z' = sin
+            endPos = {
+                x: center.x - cosR * distance,
+                y: center.y,
+                z: center.z + sinR * distance,
+            };
+            upVector = { x: 0, y: 1, z: 0 }; // Y-up
+            break;
+        case 'right':
+            // Right view: from +X looking at model
+            // For +X direction (1,0,0) rotated: x' = cos, z' = -sin
+            endPos = {
+                x: center.x + cosR * distance,
+                y: center.y,
+                z: center.z - sinR * distance,
+            };
+            upVector = { x: 0, y: 1, z: 0 }; // Y-up
+            break;
+    }
+    return { position: endPos, target: endTarget, up: upVector };
+}
+//# sourceMappingURL=camera-preset-view.js.map

package/dist/camera-preset-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-preset-view.js","sourceRoot":"","sources":["../src/camera-preset-view.ts"],"names":[],"mappings":"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"}

package/dist/camera-projection.d.ts

@@ -3,7 +3,7 @@
  * and view fitting. Extracted from Camera class using composition pattern.
  */
 import type { Vec3 } from './types.js';
-import type { CameraInternalState } from './camera-controls.js';
+import type { CameraInternalState } from './camera-state.js';
 /**
  * Handles projection math: screen-to-world and world-to-screen conversions,
  * bounding box fitting, and near/far plane management.

package/dist/camera-projection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"camera-projection.d.ts","sourceRoot":"","sources":["../src/camera-projection.ts"],"names":[],"mappings":"AAIA;;;GAGG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAGhE;;;GAGG;AACH,qBAAa,gBAAgB;IAEzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,cAAc;gBADd,KAAK,EAAE,mBAAmB,EAC1B,cAAc,EAAE,MAAM,IAAI;IAG7C;;;;;;OAMG;IACH,eAAe,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAkC3G;;;;;;;OAOG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG;QAAE,MAAM,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,IAAI,CAAA;KAAE;IA8D9H;;;;OAIG;IACH,WAAW,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI;IA4BvC;;;;OAIG;IACH,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;CAG7C"}
+{"version":3,"file":"camera-projection.d.ts","sourceRoot":"","sources":["../src/camera-projection.ts"],"names":[],"mappings":"AAIA;;;GAGG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAkB7D;;;GAGG;AACH,qBAAa,gBAAgB;IAEzB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,cAAc;gBADd,KAAK,EAAE,mBAAmB,EAC1B,cAAc,EAAE,MAAM,IAAI;IAG7C;;;;;;OAMG;IACH,eAAe,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAkC3G;;;;;;;OAOG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG;QAAE,MAAM,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,IAAI,CAAA;KAAE;IAkG9H;;;;OAIG;IACH,WAAW,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI;IAiCvC;;;;OAIG;IACH,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;CAG7C"}