@ifc-lite/renderer 1.41.1 → 1.44.0

package/dist/camera-animation.d.ts

@@ -1,16 +1,25 @@
 /**
- * Camera animation system handling tweened transitions, inertia/momentum,
- * preset views, and first-person mode.
+ * Camera animation system handling tweened transitions and inertia/momentum,
+ * plus the thin wrappers that apply a pose picked by `camera-framing.ts` (free
+ * framing) or `camera-preset-view.ts` (the ViewCube's named directions).
  * Extracted from Camera class using composition pattern.
+ *
+ * The tween's own failure story is the NaN *latch*: `velocity` accumulates in
+ * place and the loop spends a channel only while `Math.abs(v) > minVelocity`,
+ * which is false for NaN forever, so one non-finite gesture delta kills that
+ * channel for the session rather than for a frame (#2441/#2473). Framing's
+ * failure story is a different input class entirely and lives in
+ * `camera-framing.ts` with the guards that reject it.
  */
 import type { Vec3 } from './types.js';
-import type { CameraInternalState } from './camera-controls.js';
+import type { CameraInternalState } from './camera-state.js';
 import type { CameraControls } from './camera-controls.js';
 import type { CameraProjection } from './camera-projection.js';
+import { type FramingBounds } from './camera-framing.js';
 /**
  * Manages camera animations: tweened transitions between positions,
- * inertia/momentum after user interaction, preset view switching
- * with rotation cycling, and first-person movement.
+ * inertia/momentum after user interaction, and preset view switching
+ * with rotation cycling.
  */
 export declare class CameraAnimator {
     private readonly state;
@@ -31,8 +40,6 @@ export declare class CameraAnimator {
     private animationStartOrthoSize;
     private animationEndOrthoSize;
     private animationEasing;
-    private isFirstPersonMode;
-    private walkVelocity;
     private lastPresetView;
     private presetViewRotation;
     constructor(state: CameraInternalState, updateMatrices: () => void, controls: CameraControls, projection: CameraProjection);
@@ -59,6 +66,12 @@ export declare class CameraAnimator {
      */
     frameBounds(min: Vec3, max: Vec3, duration?: number): Promise<void>;
     zoomExtent(min: Vec3, max: Vec3, duration?: number): Promise<void>;
+    /**
+     * Set preset view with explicit bounds (Y-up coordinate system)
+     * Clicking the same view again rotates 90 degrees around the view axis
+     * @param buildingRotation Optional building rotation in radians (from IfcSite placement)
+     */
+    setPresetView(view: 'top' | 'bottom' | 'front' | 'back' | 'left' | 'right', bounds?: FramingBounds, buildingRotation?: number): void;
     /**
      * Animate camera to position and target
      */
@@ -71,31 +84,6 @@ export declare class CameraAnimator {
      * Easing function: easeOutCubic
      */
     private easeOutCubic;
-    /**
-     * Set first-person mode
-     */
-    enableFirstPersonMode(enabled: boolean): void;
-    /**
-     * Walk on the horizontal XZ plane (Y-up coordinate system).
-     * Forward/backward moves in the camera's horizontal facing direction.
-     * Left/right strafes perpendicular. Y position stays fixed (walking on ground).
-     * Speed scales with scene size. Movement uses smooth acceleration to avoid
-     * abrupt jumps — velocity ramps up over successive frames.
-     */
-    moveFirstPerson(forward: number, right: number, _up: number): void;
-    /**
-     * Set preset view with explicit bounds (Y-up coordinate system)
-     * Clicking the same view again rotates 90 degrees around the view axis
-     * @param buildingRotation Optional building rotation in radians (from IfcSite placement)
-     */
-    setPresetView(view: 'top' | 'bottom' | 'front' | 'back' | 'left' | 'right', bounds?: {
-        min: Vec3;
-        max: Vec3;
-    }, buildingRotation?: number): void;
-    /**
-     * Get current bounds estimate (simplified - in production would use scene bounds)
-     */
-    private getCurrentBounds;
     /**
      * Reset velocity (stop inertia)
      */

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

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

package/dist/camera-animation.js

@@ -1,10 +1,13 @@
 /* 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 { areFiniteNumbers, usableOrthoSize } from './camera-guards.js';
+import { frameBoundsTarget, framePointTarget, zoomExtentTarget, } from './camera-framing.js';
+import { presetViewTarget, resolvePresetBounds } from './camera-preset-view.js';
 /**
  * Manages camera animations: tweened transitions between positions,
- * inertia/momentum after user interaction, preset view switching
- * with rotation cycling, and first-person movement.
+ * inertia/momentum after user interaction, and preset view switching
+ * with rotation cycling.
  */
 export class CameraAnimator {
     state;
@@ -27,9 +30,6 @@ export class CameraAnimator {
     animationStartOrthoSize = null;
     animationEndOrthoSize = null;
     animationEasing = null;
-    // First-person mode
-    isFirstPersonMode = false;
-    walkVelocity = { x: 0, z: 0 };
     // Track preset view for rotation cycling (clicking same view rotates 90 degrees)
     lastPresetView = null;
     presetViewRotation = 0; // 0, 1, 2, 3 = 0, 90, 180, 270 degrees
@@ -40,15 +40,29 @@ export class CameraAnimator {
         this.projection = projection;
     }
     // --- Velocity management (called by Camera class) ---
+    // Every one of these accumulates **in place**, and the inertia loop spends a
+    // velocity only while `Math.abs(v) > minVelocity` — false for NaN. So a
+    // single non-finite gesture argument does not cost one frame of inertia: it
+    // latches the channel dead for the rest of the session, and the value never
+    // decays back under the threshold either. That is the same latch
+    // `moveFirstPerson`'s `walkVelocity` had (#2441), reached from the argument
+    // side rather than the pose side (#2473). Skip the contribution instead;
+    // the gesture itself has already been rejected by the same test downstream.
     addOrbitVelocity(deltaX, deltaY) {
+        if (!areFiniteNumbers(deltaX, deltaY))
+            return;
         this.velocity.orbit.x += deltaX * 0.001;
         this.velocity.orbit.y += deltaY * 0.001;
     }
     addPanVelocity(deltaX, deltaY, panSpeed) {
+        if (!areFiniteNumbers(deltaX, deltaY, panSpeed))
+            return;
         this.velocity.pan.x += deltaX * panSpeed * 0.1;
         this.velocity.pan.y += deltaY * panSpeed * 0.1;
     }
     addZoomVelocity(normalizedDelta) {
+        if (!Number.isFinite(normalizedDelta))
+            return;
         this.velocity.zoom += normalizedDelta * 0.1;
     }
     /**
@@ -79,9 +93,16 @@ export class CameraAnimator {
                 this.state.camera.target.x = this.animationStartTarget.x + (this.animationEndTarget.x - this.animationStartTarget.x) * t;
                 this.state.camera.target.y = this.animationStartTarget.y + (this.animationEndTarget.y - this.animationStartTarget.y) * t;
                 this.state.camera.target.z = this.animationStartTarget.z + (this.animationEndTarget.z - this.animationStartTarget.z) * t;
-                // Interpolate orthoSize if animating orthographic zoom
+                // Interpolate orthoSize if animating orthographic zoom.
+                // The animator is the second writer that bypasses `Camera.setOrthoSize`
+                // (#2461): the read-site backstop in `updateCameraMatrices` keeps the
+                // projection matrix finite but not the state, and `getOrthoSize()`
+                // reads the state — which is what a saved viewpoint persists. Keep the
+                // previous half-height when the interpolation yields nothing usable.
                 if (this.animationStartOrthoSize !== null && this.animationEndOrthoSize !== null) {
-                    this.state.orthoSize = this.animationStartOrthoSize + (this.animationEndOrthoSize - this.animationStartOrthoSize) * t;
+                    const next = usableOrthoSize(this.animationStartOrthoSize + (this.animationEndOrthoSize - this.animationStartOrthoSize) * t);
+                    if (next !== null)
+                        this.state.orthoSize = next;
                 }
                 // Interpolate up vector if animating with up
                 if (this.animationStartUp && this.animationEndUp) {
@@ -118,7 +139,9 @@ export class CameraAnimator {
                     this.state.camera.up.z = this.animationEndUp.z;
                 }
                 if (this.animationEndOrthoSize !== null) {
-                    this.state.orthoSize = this.animationEndOrthoSize;
+                    const next = usableOrthoSize(this.animationEndOrthoSize);
+                    if (next !== null)
+                        this.state.orthoSize = next;
                 }
                 this.updateMatrices();
                 this.animationStartTime = 0;
@@ -155,153 +178,63 @@ export class CameraAnimator {
         }
         return isAnimating;
     }
+    // --- Framing (pose picked in `camera-framing.ts`, applied by the tween) ---
+    //
+    // These wrappers exist on the animator because they must return the tween's
+    // promise, and the promise machinery *is* tween state. They null-check the
+    // picked target and do nothing else — in particular they do NOT re-validate
+    // the input. Each framing input is guarded exactly once, in the pure module;
+    // a second copy here would leave neither copy load-bearing, so a reverted
+    // guard would still look green.
     /**
      * Frame/center view on a point (keeps current distance and direction)
      * Standard CAD "Frame Selection" behavior
      */
     async framePoint(point, duration = 300) {
-        // Keep current viewing direction and distance
-        const dir = {
-            x: this.state.camera.position.x - this.state.camera.target.x,
-            y: this.state.camera.position.y - this.state.camera.target.y,
-            z: this.state.camera.position.z - this.state.camera.target.z,
-        };
-        // New position: point + current offset
-        const endPos = {
-            x: point.x + dir.x,
-            y: point.y + dir.y,
-            z: point.z + dir.z,
-        };
-        return this.animateTo(endPos, point, duration);
+        const fit = framePointTarget(this.state, point);
+        if (!fit)
+            return;
+        return this.animateTo(fit.position, fit.target, duration, fit.orthoSize);
     }
     /**
      * Frame selection - zoom to fit bounds while keeping current view direction
      * This is what "Frame Selection" should do - zoom to fill screen
      */
     async frameBounds(min, max, duration = 300) {
-        const center = {
-            x: (min.x + max.x) / 2,
-            y: (min.y + max.y) / 2,
-            z: (min.z + max.z) / 2,
-        };
-        const size = {
-            x: max.x - min.x,
-            y: max.y - min.y,
-            z: max.z - min.z,
-        };
-        const maxSize = Math.max(size.x, size.y, size.z);
-        if (maxSize < 1e-6) {
-            // Very small or zero size - just center on it
-            return this.framePoint(center, duration);
-        }
-        // Calculate required distance based on FOV to fit bounds
-        const fovFactor = Math.tan(this.state.camera.fov / 2);
-        const distance = (maxSize / 2) / fovFactor * 1.2; // 1.2x padding for nice framing
-        // Get current viewing direction from view matrix (more reliable than position-target)
-        // View matrix forward is -Z axis in view space
-        const viewMatrix = this.state.viewMatrix.m;
-        // Extract forward direction from view matrix (negative Z column, normalized)
-        let dir = {
-            x: -viewMatrix[8], // -m[2][0] (forward X)
-            y: -viewMatrix[9], // -m[2][1] (forward Y)
-            z: -viewMatrix[10], // -m[2][2] (forward Z)
-        };
-        const dirLen = Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
-        // Normalize direction
-        if (dirLen > 1e-6) {
-            dir.x /= dirLen;
-            dir.y /= dirLen;
-            dir.z /= dirLen;
-        }
-        else {
-            // Fallback: use position-target if view matrix is invalid
-            dir = {
-                x: this.state.camera.position.x - this.state.camera.target.x,
-                y: this.state.camera.position.y - this.state.camera.target.y,
-                z: this.state.camera.position.z - this.state.camera.target.z,
-            };
-            const fallbackLen = Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
-            if (fallbackLen > 1e-6) {
-                dir.x /= fallbackLen;
-                dir.y /= fallbackLen;
-                dir.z /= fallbackLen;
-            }
-            else {
-                // Last resort: southeast isometric
-                dir.x = 0.6;
-                dir.y = 0.5;
-                dir.z = 0.6;
-                const len = Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
-                dir.x /= len;
-                dir.y /= len;
-                dir.z /= len;
-            }
-        }
-        // New position: center + direction * distance
-        const endPos = {
-            x: center.x + dir.x * distance,
-            y: center.y + dir.y * distance,
-            z: center.z + dir.z * distance,
-        };
-        // Calculate orthoSize for orthographic mode so zoom level resets properly
-        const aspect = this.state.camera.aspect || 1;
-        const endOrthoSize = this.state.projectionMode === 'orthographic'
-            ? Math.max(0.01, maxSize / 2, maxSize / 2 / aspect) * 1.2
-            : undefined;
-        return this.animateTo(endPos, center, duration, endOrthoSize);
+        const fit = frameBoundsTarget(this.state, min, max);
+        if (!fit)
+            return;
+        return this.animateTo(fit.position, fit.target, duration, fit.orthoSize);
     }
     async zoomExtent(min, max, duration = 300) {
-        const center = {
-            x: (min.x + max.x) / 2,
-            y: (min.y + max.y) / 2,
-            z: (min.z + max.z) / 2,
-        };
-        const size = {
-            x: max.x - min.x,
-            y: max.y - min.y,
-            z: max.z - min.z,
-        };
-        const maxSize = Math.max(size.x, size.y, size.z);
-        // Calculate required distance based on FOV
-        const fovFactor = Math.tan(this.state.camera.fov / 2);
-        const distance = (maxSize / 2) / fovFactor * 1.5; // 1.5x for padding
+        const fit = zoomExtentTarget(this.state, min, max);
+        if (!fit)
+            return;
         // Update near/far planes dynamically
-        this.projection.updateNearFarPlanes(distance);
-        // Keep current viewing direction
-        const dir = {
-            x: this.state.camera.position.x - this.state.camera.target.x,
-            y: this.state.camera.position.y - this.state.camera.target.y,
-            z: this.state.camera.position.z - this.state.camera.target.z,
-        };
-        const currentDistance = Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
-        // Normalize direction
-        if (currentDistance > 1e-10) {
-            dir.x /= currentDistance;
-            dir.y /= currentDistance;
-            dir.z /= currentDistance;
+        this.projection.updateNearFarPlanes(fit.fitDistance);
+        return this.animateTo(fit.position, fit.target, duration, fit.orthoSize);
+    }
+    /**
+     * Set preset view with explicit bounds (Y-up coordinate system)
+     * Clicking the same view again rotates 90 degrees around the view axis
+     * @param buildingRotation Optional building rotation in radians (from IfcSite placement)
+     */
+    setPresetView(view, bounds, buildingRotation) {
+        // Resolved and validated before the rotation cycles, so a rejected preset
+        // leaves the ViewCube's cycle position where it was.
+        const useBounds = resolvePresetBounds(this.state, bounds);
+        if (!useBounds)
+            return;
+        // Check if clicking the same view again - cycle rotation
+        if (this.lastPresetView === view) {
+            this.presetViewRotation = (this.presetViewRotation + 1) % 4;
         }
         else {
-            // Fallback direction
-            dir.x = 0.6;
-            dir.y = 0.5;
-            dir.z = 0.6;
-            const len = Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
-            dir.x /= len;
-            dir.y /= len;
-            dir.z /= len;
+            this.lastPresetView = view;
+            this.presetViewRotation = 0;
         }
-        // New position: center + direction * distance
-        const endPos = {
-            x: center.x + dir.x * distance,
-            y: center.y + dir.y * distance,
-            z: center.z + dir.z * distance,
-        };
-        // Calculate orthoSize for orthographic mode so zoom level resets properly
-        const aspect = this.state.camera.aspect || 1;
-        const endOrthoSize = this.state.projectionMode === 'orthographic'
-            ? Math.max(0.01, maxSize / 2, maxSize / 2 / aspect) * 1.5
-            : undefined;
-        return this.animateTo(endPos, center, duration, endOrthoSize);
+        const fit = presetViewTarget(this.state, view, useBounds, this.presetViewRotation, buildingRotation);
+        this.animateToWithUp(fit.position, fit.target, fit.up, 300);
     }
     /**
      * Animate camera to position and target
@@ -377,226 +310,6 @@ export class CameraAnimator {
     easeOutCubic(t) {
         return 1 - Math.pow(1 - t, 3);
     }
-    /**
-     * Set first-person mode
-     */
-    enableFirstPersonMode(enabled) {
-        this.isFirstPersonMode = enabled;
-    }
-    /**
-     * Walk on the horizontal XZ plane (Y-up coordinate system).
-     * Forward/backward moves in the camera's horizontal facing direction.
-     * Left/right strafes perpendicular. Y position stays fixed (walking on ground).
-     * Speed scales with scene size. Movement uses smooth acceleration to avoid
-     * abrupt jumps — velocity ramps up over successive frames.
-     */
-    moveFirstPerson(forward, right, _up) {
-        // Camera forward direction projected onto XZ plane
-        const dir = {
-            x: this.state.camera.target.x - this.state.camera.position.x,
-            z: this.state.camera.target.z - this.state.camera.position.z,
-        };
-        const horizLen = Math.sqrt(dir.x * dir.x + dir.z * dir.z);
-        if (horizLen < 1e-10)
-            return;
-        // Normalized horizontal forward and right vectors
-        const fwdX = dir.x / horizLen;
-        const fwdZ = dir.z / horizLen;
-        const rightX = -fwdZ;
-        const rightZ = fwdX;
-        // Target velocity from input (forward/right can be -2..2 with sprint)
-        const targetVelX = fwdX * forward + rightX * right;
-        const targetVelZ = fwdZ * forward + rightZ * right;
-        // Smooth acceleration: lerp current walk velocity toward target
-        this.walkVelocity.x += (targetVelX - this.walkVelocity.x) * 0.15;
-        this.walkVelocity.z += (targetVelZ - this.walkVelocity.z) * 0.15;
-        // Speed proportional to scene size (use camera-target distance as proxy)
-        const camDir = {
-            x: this.state.camera.position.x - this.state.camera.target.x,
-            y: this.state.camera.position.y - this.state.camera.target.y,
-            z: this.state.camera.position.z - this.state.camera.target.z,
-        };
-        const distance = Math.sqrt(camDir.x * camDir.x + camDir.y * camDir.y + camDir.z * camDir.z);
-        const speed = Math.max(0.02, distance * 0.004);
-        // Apply smoothed velocity
-        const offsetX = this.walkVelocity.x * speed;
-        const offsetZ = this.walkVelocity.z * speed;
-        // Move both position and target by the same offset (preserves view direction)
-        this.state.camera.position.x += offsetX;
-        this.state.camera.position.z += offsetZ;
-        this.state.camera.target.x += offsetX;
-        this.state.camera.target.z += offsetZ;
-        this.updateMatrices();
-    }
-    /**
-     * Set preset view with explicit bounds (Y-up coordinate system)
-     * Clicking the same view again rotates 90 degrees around the view axis
-     * @param buildingRotation Optional building rotation in radians (from IfcSite placement)
-     */
-    setPresetView(view, bounds, buildingRotation) {
-        const useBounds = bounds || this.getCurrentBounds();
-        if (!useBounds) {
-            console.warn('[Camera] No bounds available for setPresetView');
-            return;
-        }
-        // Check if clicking the same view again - cycle rotation
-        if (this.lastPresetView === view) {
-            this.presetViewRotation = (this.presetViewRotation + 1) % 4;
-        }
-        else {
-            this.lastPresetView = view;
-            this.presetViewRotation = 0;
-        }
-        const center = {
-            x: (useBounds.min.x + useBounds.max.x) / 2,
-            y: (useBounds.min.y + useBounds.max.y) / 2,
-            z: (useBounds.min.z + useBounds.max.z) / 2,
-        };
-        const size = {
-            x: useBounds.max.x - useBounds.min.x,
-            y: useBounds.max.y - useBounds.min.y,
-            z: useBounds.max.z - useBounds.min.z,
-        };
-        const maxSize = Math.max(size.x, size.y, size.z);
-        // Calculate distance based on FOV for proper fit
-        const fovFactor = Math.tan(this.state.camera.fov / 2);
-        const distance = (maxSize / 2) / fovFactor * 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
-        // Up vector rotation options for top/bottom views (rotate around Y axis)
-        // 0: -Z, 1: -X, 2: +Z, 3: +X
-        const topUpVectors = [
-            { x: 0, y: 0, z: -1 }, // 0 degrees - North up
-            { x: -1, y: 0, z: 0 }, // 90 degrees - West up
-            { x: 0, y: 0, z: 1 }, // 180 degrees - South up
-            { x: 1, y: 0, z: 0 }, // 270 degrees - East up
-        ];
-        const bottomUpVectors = [
-            { x: 0, y: 0, z: 1 }, // 0 degrees - South up
-            { x: 1, y: 0, z: 0 }, // 90 degrees - East up
-            { x: 0, y: 0, z: -1 }, // 180 degrees - North up
-            { x: -1, y: 0, z: 0 }, // 270 degrees - West up
-        ];
-        // Apply building rotation if present (rotate around Y axis)
-        const cosR = buildingRotation !== undefined && buildingRotation !== 0 ? Math.cos(buildingRotation) : 1.0;
-        const sinR = buildingRotation !== undefined && buildingRotation !== 0 ? Math.sin(buildingRotation) : 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;
-                const thetaPerRotation = [0, Math.PI / 2, Math.PI, -Math.PI / 2];
-                const thetaWorld = thetaPerRotation[this.presetViewRotation] + (buildingRotation ?? 0);
-                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[this.presetViewRotation] + (buildingRotation ?? 0);
-                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;
-        }
-        this.animateToWithUp(endPos, endTarget, upVector, 300);
-    }
-    /**
-     * Get current bounds estimate (simplified - in production would use scene bounds)
-     */
-    getCurrentBounds() {
-        // Estimate bounds from camera distance
-        const dir = {
-            x: this.state.camera.position.x - this.state.camera.target.x,
-            y: this.state.camera.position.y - this.state.camera.target.y,
-            z: this.state.camera.position.z - this.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: this.state.camera.target.x - size,
-                y: this.state.camera.target.y - size,
-                z: this.state.camera.target.z - size,
-            },
-            max: {
-                x: this.state.camera.target.x + size,
-                y: this.state.camera.target.y + size,
-                z: this.state.camera.target.z + size,
-            },
-        };
-    }
     /**
      * Reset velocity (stop inertia)
      */