@ifc-lite/renderer 1.6.1 → 1.8.0

package/dist/camera.js

@@ -2,68 +2,57 @@
  * 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 { MathUtils } from './math.js';
+import { CameraControls } from './camera-controls.js';
+import { CameraAnimator } from './camera-animation.js';
+import { CameraProjection } from './camera-projection.js';
 export class Camera {
-    camera;
-    viewMatrix;
-    projMatrix;
-    viewProjMatrix;
-    // Inertia system
-    velocity = { orbit: { x: 0, y: 0 }, pan: { x: 0, y: 0 }, zoom: 0 };
-    damping = 0.92; // Inertia factor (0-1), higher = more damping
-    minVelocity = 0.001; // Minimum velocity threshold
-    // Animation system
-    animationStartTime = 0;
-    animationDuration = 0;
-    animationStartPos = null;
-    animationStartTarget = null;
-    animationEndPos = null;
-    animationEndTarget = null;
-    animationStartUp = null;
-    animationEndUp = null;
-    animationEasing = null;
-    // First-person mode
-    isFirstPersonMode = false;
-    firstPersonSpeed = 0.1;
-    // Dynamic orbit pivot (for orbiting around selected element or cursor point)
-    orbitPivot = null;
-    // Track preset view for rotation cycling (clicking same view rotates 90°)
-    lastPresetView = null;
-    presetViewRotation = 0; // 0, 1, 2, 3 = 0°, 90°, 180°, 270°
+    state;
+    controls;
+    animator;
+    projection;
     constructor() {
         // Geometry is converted from IFC Z-up to WebGL Y-up during import
-        this.camera = {
-            position: { x: 50, y: 50, z: 100 },
-            target: { x: 0, y: 0, z: 0 },
-            up: { x: 0, y: 1, z: 0 }, // Y-up (standard WebGL)
-            fov: Math.PI / 4,
-            aspect: 1,
-            near: 0.1,
-            far: 100000, // Increased default far plane for large models
+        this.state = {
+            camera: {
+                position: { x: 50, y: 50, z: 100 },
+                target: { x: 0, y: 0, z: 0 },
+                up: { x: 0, y: 1, z: 0 }, // Y-up (standard WebGL)
+                fov: Math.PI / 4,
+                aspect: 1,
+                near: 0.1,
+                far: 100000, // Increased default far plane for large models
+            },
+            viewMatrix: MathUtils.identity(),
+            projMatrix: MathUtils.identity(),
+            viewProjMatrix: MathUtils.identity(),
+            projectionMode: 'perspective',
+            orthoSize: 50, // Default half-height in world units
         };
-        this.viewMatrix = MathUtils.identity();
-        this.projMatrix = MathUtils.identity();
-        this.viewProjMatrix = MathUtils.identity();
+        const updateMatrices = () => this.updateMatrices();
+        this.controls = new CameraControls(this.state, updateMatrices);
+        this.projection = new CameraProjection(this.state, updateMatrices);
+        this.animator = new CameraAnimator(this.state, updateMatrices, this.controls, this.projection);
         this.updateMatrices();
     }
     /**
      * Set camera aspect ratio
      */
     setAspect(aspect) {
-        this.camera.aspect = aspect;
+        this.state.camera.aspect = aspect;
         this.updateMatrices();
     }
     /**
      * Set camera position
      */
     setPosition(x, y, z) {
-        this.camera.position = { x, y, z };
+        this.state.camera.position = { x, y, z };
         this.updateMatrices();
     }
     /**
      * Set camera target
      */
     setTarget(x, y, z) {
-        this.camera.target = { x, y, z };
+        this.state.camera.target = { x, y, z };
         this.updateMatrices();
     }
     /**
@@ -71,130 +60,41 @@ export class Camera {
      * When set, orbit() will rotate around this point instead of the camera target
      */
     setOrbitPivot(pivot) {
-        this.orbitPivot = pivot ? { ...pivot } : null;
+        this.controls.setOrbitPivot(pivot);
     }
     /**
      * Get current orbit pivot (returns temporary pivot if set, otherwise target)
      */
     getOrbitPivot() {
-        return this.orbitPivot ? { ...this.orbitPivot } : { ...this.camera.target };
+        return this.controls.getOrbitPivot();
     }
     /**
      * Check if a temporary orbit pivot is set
      */
     hasOrbitPivot() {
-        return this.orbitPivot !== null;
+        return this.controls.hasOrbitPivot();
     }
     /**
      * Orbit around target or pivot (Y-up coordinate system)
      * If an orbit pivot is set, orbits around that point and moves target along
      */
     orbit(deltaX, deltaY, addVelocity = false) {
-        // Always ensure Y-up for consistent orbit behavior
-        this.camera.up = { x: 0, y: 1, z: 0 };
-        // Reset preset view tracking when user orbits
-        this.lastPresetView = null;
-        this.presetViewRotation = 0;
-        // Invert controls: mouse movement direction = model rotation direction
-        const dx = -deltaX * 0.01;
-        const dy = -deltaY * 0.01;
-        // Use orbit pivot if set, otherwise use target
-        const pivotPoint = this.orbitPivot || this.camera.target;
-        const dir = {
-            x: this.camera.position.x - pivotPoint.x,
-            y: this.camera.position.y - pivotPoint.y,
-            z: this.camera.position.z - pivotPoint.z,
-        };
-        const distance = Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
-        if (distance < 1e-6)
-            return;
-        // Y-up coordinate system using standard spherical coordinates
-        // theta: horizontal rotation around Y axis
-        // phi: vertical angle from Y axis (0 = top, PI = bottom)
-        let currentPhi = Math.acos(Math.max(-1, Math.min(1, dir.y / distance)));
-        // When at poles (top/bottom view), use a stable theta based on current direction
-        // to avoid gimbal lock issues
-        let theta;
-        const sinPhi = Math.sin(currentPhi);
-        if (sinPhi > 0.05) {
-            // Normal case - calculate theta from horizontal position
-            theta = Math.atan2(dir.x, dir.z);
-        }
-        else {
-            // At a pole - determine which one and push away
-            theta = 0; // Default theta when at pole
-            if (currentPhi < Math.PI / 2) {
-                // Top pole (phi ≈ 0) - push down
-                currentPhi = 0.15;
-            }
-            else {
-                // Bottom pole (phi ≈ π) - push up
-                currentPhi = Math.PI - 0.15;
-            }
-        }
-        theta += dx;
-        const phi = currentPhi + dy;
-        // Clamp phi to prevent gimbal lock (stay away from exact poles)
-        const phiClamped = Math.max(0.15, Math.min(Math.PI - 0.15, phi));
-        // Calculate new camera position around pivot
-        const newPosX = pivotPoint.x + distance * Math.sin(phiClamped) * Math.sin(theta);
-        const newPosY = pivotPoint.y + distance * Math.cos(phiClamped);
-        const newPosZ = pivotPoint.z + distance * Math.sin(phiClamped) * Math.cos(theta);
-        // Update camera position
-        this.camera.position.x = newPosX;
-        this.camera.position.y = newPosY;
-        this.camera.position.z = newPosZ;
+        this.animator.resetPresetTracking();
+        this.controls.orbit(deltaX, deltaY);
         if (addVelocity) {
-            this.velocity.orbit.x += deltaX * 0.001;
-            this.velocity.orbit.y += deltaY * 0.001;
+            this.animator.addOrbitVelocity(deltaX, deltaY);
         }
-        this.updateMatrices();
     }
     /**
      * Pan camera (Y-up coordinate system)
      */
     pan(deltaX, deltaY, addVelocity = false) {
-        const dir = {
-            x: this.camera.position.x - this.camera.target.x,
-            y: this.camera.position.y - this.camera.target.y,
-            z: this.camera.position.z - this.camera.target.z,
-        };
-        const distance = Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
-        // Right vector: cross product of direction and up (0,1,0)
-        const right = {
-            x: -dir.z,
-            y: 0,
-            z: dir.x,
-        };
-        const rightLen = Math.sqrt(right.x * right.x + right.z * right.z);
-        if (rightLen > 1e-10) {
-            right.x /= rightLen;
-            right.z /= rightLen;
-        }
-        // Up vector: cross product of right and direction
-        const up = {
-            x: (right.z * dir.y - right.y * dir.z),
-            y: (right.x * dir.z - right.z * dir.x),
-            z: (right.y * dir.x - right.x * dir.y),
-        };
-        const upLen = Math.sqrt(up.x * up.x + up.y * up.y + up.z * up.z);
-        if (upLen > 1e-10) {
-            up.x /= upLen;
-            up.y /= upLen;
-            up.z /= upLen;
-        }
-        const panSpeed = distance * 0.001;
-        this.camera.target.x += (right.x * deltaX + up.x * deltaY) * panSpeed;
-        this.camera.target.y += (right.y * deltaX + up.y * deltaY) * panSpeed;
-        this.camera.target.z += (right.z * deltaX + up.z * deltaY) * panSpeed;
-        this.camera.position.x += (right.x * deltaX + up.x * deltaY) * panSpeed;
-        this.camera.position.y += (right.y * deltaX + up.y * deltaY) * panSpeed;
-        this.camera.position.z += (right.z * deltaX + up.z * deltaY) * panSpeed;
+        // Pan speed depends on distance; compute before pan (pan preserves distance)
+        const panSpeed = this.getDistance() * 0.001;
+        this.controls.pan(deltaX, deltaY);
         if (addVelocity) {
-            this.velocity.pan.x += deltaX * panSpeed * 0.1;
-            this.velocity.pan.y += deltaY * panSpeed * 0.1;
+            this.animator.addPanVelocity(deltaX, deltaY, panSpeed);
         }
-        this.updateMatrices();
     }
     /**
      * Zoom camera towards mouse position
@@ -206,74 +106,11 @@ export class Camera {
      * @param canvasHeight - Canvas height
      */
     zoom(delta, addVelocity = false, mouseX, mouseY, canvasWidth, canvasHeight) {
-        const dir = {
-            x: this.camera.position.x - this.camera.target.x,
-            y: this.camera.position.y - this.camera.target.y,
-            z: this.camera.position.z - this.camera.target.z,
-        };
-        const distance = Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
-        // Normalize delta (wheel events can have large values)
-        const normalizedDelta = Math.sign(delta) * Math.min(Math.abs(delta) * 0.001, 0.1);
-        const zoomFactor = 1 + normalizedDelta;
-        // If mouse position provided, zoom towards that point
-        if (mouseX !== undefined && mouseY !== undefined && canvasWidth && canvasHeight) {
-            // Convert mouse to normalized device coordinates (-1 to 1)
-            const ndcX = (mouseX / canvasWidth) * 2 - 1;
-            const ndcY = 1 - (mouseY / canvasHeight) * 2; // Flip Y
-            // Calculate offset from center in world space
-            // Use the camera's right and up vectors
-            const forward = {
-                x: -dir.x / distance,
-                y: -dir.y / distance,
-                z: -dir.z / distance,
-            };
-            // Right = forward × up
-            const up = this.camera.up;
-            const right = {
-                x: forward.y * up.z - forward.z * up.y,
-                y: forward.z * up.x - forward.x * up.z,
-                z: forward.x * up.y - forward.y * up.x,
-            };
-            const rightLen = Math.sqrt(right.x * right.x + right.y * right.y + right.z * right.z);
-            if (rightLen > 1e-10) {
-                right.x /= rightLen;
-                right.y /= rightLen;
-                right.z /= rightLen;
-            }
-            // Actual up = right × forward
-            const actualUp = {
-                x: right.y * forward.z - right.z * forward.y,
-                y: right.z * forward.x - right.x * forward.z,
-                z: right.x * forward.y - right.y * forward.x,
-            };
-            // Calculate view frustum size at target distance
-            const halfHeight = distance * Math.tan(this.camera.fov / 2);
-            const halfWidth = halfHeight * this.camera.aspect;
-            // World offset from center towards mouse position
-            const worldOffsetX = ndcX * halfWidth;
-            const worldOffsetY = ndcY * halfHeight;
-            // Point in world space that mouse is pointing at (on the target plane)
-            const mouseWorldPoint = {
-                x: this.camera.target.x + right.x * worldOffsetX + actualUp.x * worldOffsetY,
-                y: this.camera.target.y + right.y * worldOffsetX + actualUp.y * worldOffsetY,
-                z: this.camera.target.z + right.z * worldOffsetX + actualUp.z * worldOffsetY,
-            };
-            // Move both camera and target towards mouse point while zooming
-            const moveAmount = (1 - zoomFactor); // Negative when zooming in
-            this.camera.target.x += (mouseWorldPoint.x - this.camera.target.x) * moveAmount;
-            this.camera.target.y += (mouseWorldPoint.y - this.camera.target.y) * moveAmount;
-            this.camera.target.z += (mouseWorldPoint.z - this.camera.target.z) * moveAmount;
-        }
-        // Apply zoom (scale distance)
-        const newDistance = Math.max(0.1, distance * zoomFactor);
-        const scale = newDistance / distance;
-        this.camera.position.x = this.camera.target.x + dir.x * scale;
-        this.camera.position.y = this.camera.target.y + dir.y * scale;
-        this.camera.position.z = this.camera.target.z + dir.z * scale;
+        this.controls.zoom(delta, mouseX, mouseY, canvasWidth, canvasHeight);
         if (addVelocity) {
-            this.velocity.zoom += normalizedDelta * 0.1;
+            const normalizedDelta = Math.sign(delta) * Math.min(Math.abs(delta) * 0.001, 0.1);
+            this.animator.addZoomVelocity(normalizedDelta);
         }
-        this.updateMatrices();
     }
     /**
      * Fit view to bounding box
@@ -281,619 +118,114 @@ export class Camera {
      * Y-up coordinate system: Y is vertical
      */
     fitToBounds(min, max) {
-        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);
-        const distance = maxSize * 2.0;
-        this.camera.target = center;
-        // Southeast isometric view for Y-up:
-        // Position camera above and to the front-right of the model
-        this.camera.position = {
-            x: center.x + distance * 0.6, // Right
-            y: center.y + distance * 0.5, // Above
-            z: center.z + distance * 0.6, // Front
-        };
-        // Dynamic near/far plane calculation to prevent Z-fighting
-        // Keep near/far ratio under 10000:1 for better depth precision
-        const optimalNear = Math.max(0.01, distance * 0.001); // 0.1% of distance
-        const optimalFar = distance * 10; // 10x distance for safety margin
-        // Ensure ratio is reasonable (max 10000:1)
-        const maxRatio = 10000;
-        if (optimalFar / optimalNear > maxRatio) {
-            // Adjust far plane to maintain ratio
-            this.camera.far = optimalNear * maxRatio;
-        }
-        else {
-            this.camera.far = optimalFar;
-        }
-        this.camera.near = optimalNear;
-        this.updateMatrices();
+        this.projection.fitToBounds(min, max);
     }
     /**
      * Update camera animation and inertia
      * Returns true if camera is still animating
      */
-    update(_deltaTime) {
-        // deltaTime reserved for future physics-based animation smoothing
-        void _deltaTime;
-        let isAnimating = false;
-        // Handle animation
-        if (this.animationStartTime > 0 && this.animationDuration > 0) {
-            const elapsed = Date.now() - this.animationStartTime;
-            const progress = Math.min(elapsed / this.animationDuration, 1);
-            if (progress < 1 && this.animationStartPos && this.animationEndPos &&
-                this.animationStartTarget && this.animationEndTarget && this.animationEasing) {
-                const t = this.animationEasing(progress);
-                this.camera.position.x = this.animationStartPos.x + (this.animationEndPos.x - this.animationStartPos.x) * t;
-                this.camera.position.y = this.animationStartPos.y + (this.animationEndPos.y - this.animationStartPos.y) * t;
-                this.camera.position.z = this.animationStartPos.z + (this.animationEndPos.z - this.animationStartPos.z) * t;
-                this.camera.target.x = this.animationStartTarget.x + (this.animationEndTarget.x - this.animationStartTarget.x) * t;
-                this.camera.target.y = this.animationStartTarget.y + (this.animationEndTarget.y - this.animationStartTarget.y) * t;
-                this.camera.target.z = this.animationStartTarget.z + (this.animationEndTarget.z - this.animationStartTarget.z) * t;
-                // Interpolate up vector if animating with up
-                if (this.animationStartUp && this.animationEndUp) {
-                    // SLERP-like interpolation for up vector (normalized lerp)
-                    let upX = this.animationStartUp.x + (this.animationEndUp.x - this.animationStartUp.x) * t;
-                    let upY = this.animationStartUp.y + (this.animationEndUp.y - this.animationStartUp.y) * t;
-                    let upZ = this.animationStartUp.z + (this.animationEndUp.z - this.animationStartUp.z) * t;
-                    // Normalize
-                    const len = Math.sqrt(upX * upX + upY * upY + upZ * upZ);
-                    if (len > 0.0001) {
-                        this.camera.up.x = upX / len;
-                        this.camera.up.y = upY / len;
-                        this.camera.up.z = upZ / len;
-                    }
-                }
-                this.updateMatrices();
-                isAnimating = true;
-            }
-            else {
-                // Animation complete - set final values
-                if (this.animationEndPos) {
-                    this.camera.position.x = this.animationEndPos.x;
-                    this.camera.position.y = this.animationEndPos.y;
-                    this.camera.position.z = this.animationEndPos.z;
-                }
-                if (this.animationEndTarget) {
-                    this.camera.target.x = this.animationEndTarget.x;
-                    this.camera.target.y = this.animationEndTarget.y;
-                    this.camera.target.z = this.animationEndTarget.z;
-                }
-                if (this.animationEndUp) {
-                    this.camera.up.x = this.animationEndUp.x;
-                    this.camera.up.y = this.animationEndUp.y;
-                    this.camera.up.z = this.animationEndUp.z;
-                }
-                this.updateMatrices();
-                this.animationStartTime = 0;
-                this.animationDuration = 0;
-                this.animationStartPos = null;
-                this.animationEndPos = null;
-                this.animationStartTarget = null;
-                this.animationEndTarget = null;
-                this.animationStartUp = null;
-                this.animationEndUp = null;
-                this.animationEasing = null;
-            }
-        }
-        // Apply inertia
-        if (Math.abs(this.velocity.orbit.x) > this.minVelocity || Math.abs(this.velocity.orbit.y) > this.minVelocity) {
-            this.orbit(this.velocity.orbit.x * 100, this.velocity.orbit.y * 100, false);
-            this.velocity.orbit.x *= this.damping;
-            this.velocity.orbit.y *= this.damping;
-            isAnimating = true;
-        }
-        if (Math.abs(this.velocity.pan.x) > this.minVelocity || Math.abs(this.velocity.pan.y) > this.minVelocity) {
-            this.pan(this.velocity.pan.x * 1000, this.velocity.pan.y * 1000, false);
-            this.velocity.pan.x *= this.damping;
-            this.velocity.pan.y *= this.damping;
-            isAnimating = true;
-        }
-        if (Math.abs(this.velocity.zoom) > this.minVelocity) {
-            this.zoom(this.velocity.zoom * 1000, false);
-            this.velocity.zoom *= this.damping;
-            isAnimating = true;
-        }
-        return isAnimating;
+    update(deltaTime) {
+        return this.animator.update(deltaTime);
     }
     /**
      * Animate camera to fit bounds (southeast isometric view)
      * Y-up coordinate system
      */
     async zoomToFit(min, max, duration = 500) {
-        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);
-        const distance = maxSize * 2.0;
-        const endTarget = center;
-        // Southeast isometric view for Y-up (same as fitToBounds)
-        const endPos = {
-            x: center.x + distance * 0.6,
-            y: center.y + distance * 0.5,
-            z: center.z + distance * 0.6,
-        };
-        return this.animateTo(endPos, endTarget, duration);
+        return this.animator.zoomToFit(min, max, duration);
     }
-    /**
-     * Zoom to fit bounds WITHOUT changing view direction
-     * Just centers on bounds and adjusts distance to fit
-     */
     /**
      * 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.camera.position.x - this.camera.target.x,
-            y: this.camera.position.y - this.camera.target.y,
-            z: this.camera.position.z - this.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);
+        return this.animator.framePoint(point, duration);
     }
     /**
      * 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.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.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.camera.position.x - this.camera.target.x,
-                y: this.camera.position.y - this.camera.target.y,
-                z: this.camera.position.z - this.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,
-        };
-        return this.animateTo(endPos, center, duration);
+        return this.animator.frameBounds(min, max, duration);
     }
     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.camera.fov / 2);
-        const distance = (maxSize / 2) / fovFactor * 1.5; // 1.5x for padding
-        // Update near/far planes dynamically
-        this.updateNearFarPlanes(distance);
-        // Keep current viewing direction
-        const dir = {
-            x: this.camera.position.x - this.camera.target.x,
-            y: this.camera.position.y - this.camera.target.y,
-            z: this.camera.position.z - this.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;
-        }
-        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;
-        }
-        // 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,
-        };
-        return this.animateTo(endPos, center, duration);
+        return this.animator.zoomExtent(min, max, duration);
     }
     /**
      * Animate camera to position and target
      */
     async animateTo(endPos, endTarget, duration = 500) {
-        this.animationStartPos = { ...this.camera.position };
-        this.animationStartTarget = { ...this.camera.target };
-        this.animationEndPos = endPos;
-        this.animationEndTarget = endTarget;
-        this.animationStartUp = null;
-        this.animationEndUp = null;
-        this.animationDuration = duration;
-        this.animationStartTime = Date.now();
-        this.animationEasing = this.easeOutCubic;
-        // Wait for animation to complete
-        return new Promise((resolve) => {
-            const checkAnimation = () => {
-                if (this.animationStartTime === 0) {
-                    resolve();
-                }
-                else {
-                    requestAnimationFrame(checkAnimation);
-                }
-            };
-            checkAnimation();
-        });
+        return this.animator.animateTo(endPos, endTarget, duration);
     }
     /**
      * Animate camera to position, target, and up vector (for orthogonal preset views)
      */
     async animateToWithUp(endPos, endTarget, endUp, duration = 500) {
-        // Clear all velocities to prevent inertia from interfering with animation
-        this.velocity.orbit.x = 0;
-        this.velocity.orbit.y = 0;
-        this.velocity.pan.x = 0;
-        this.velocity.pan.y = 0;
-        this.velocity.zoom = 0;
-        this.animationStartPos = { ...this.camera.position };
-        this.animationStartTarget = { ...this.camera.target };
-        this.animationStartUp = { ...this.camera.up };
-        this.animationEndPos = endPos;
-        this.animationEndTarget = endTarget;
-        this.animationEndUp = endUp;
-        this.animationDuration = duration;
-        this.animationStartTime = Date.now();
-        this.animationEasing = this.easeOutCubic;
-        // Wait for animation to complete
-        return new Promise((resolve) => {
-            const checkAnimation = () => {
-                if (this.animationStartTime === 0) {
-                    resolve();
-                }
-                else {
-                    requestAnimationFrame(checkAnimation);
-                }
-            };
-            checkAnimation();
-        });
-    }
-    /**
-     * Easing function: easeOutCubic
-     */
-    easeOutCubic(t) {
-        return 1 - Math.pow(1 - t, 3);
+        return this.animator.animateToWithUp(endPos, endTarget, endUp, duration);
     }
     /**
      * Set first-person mode
      */
     enableFirstPersonMode(enabled) {
-        this.isFirstPersonMode = enabled;
+        this.animator.enableFirstPersonMode(enabled);
     }
     /**
      * Move in first-person mode (Y-up coordinate system)
      */
     moveFirstPerson(forward, right, up) {
-        if (!this.isFirstPersonMode)
-            return;
-        const dir = {
-            x: this.camera.target.x - this.camera.position.x,
-            y: this.camera.target.y - this.camera.position.y,
-            z: this.camera.target.z - this.camera.position.z,
-        };
-        const len = Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
-        if (len > 1e-10) {
-            dir.x /= len;
-            dir.y /= len;
-            dir.z /= len;
-        }
-        // Right vector: cross product of direction and up (0,1,0)
-        const rightVec = {
-            x: -dir.z,
-            y: 0,
-            z: dir.x,
-        };
-        const rightLen = Math.sqrt(rightVec.x * rightVec.x + rightVec.z * rightVec.z);
-        if (rightLen > 1e-10) {
-            rightVec.x /= rightLen;
-            rightVec.z /= rightLen;
-        }
-        // Up vector: cross product of right and direction
-        const upVec = {
-            x: (rightVec.z * dir.y - rightVec.y * dir.z),
-            y: (rightVec.x * dir.z - rightVec.z * dir.x),
-            z: (rightVec.y * dir.x - rightVec.x * dir.y),
-        };
-        const speed = this.firstPersonSpeed;
-        this.camera.position.x += (dir.x * forward + rightVec.x * right + upVec.x * up) * speed;
-        this.camera.position.y += (dir.y * forward + rightVec.y * right + upVec.y * up) * speed;
-        this.camera.position.z += (dir.z * forward + rightVec.z * right + upVec.z * up) * speed;
-        this.camera.target.x += (dir.x * forward + rightVec.x * right + upVec.x * up) * speed;
-        this.camera.target.y += (dir.y * forward + rightVec.y * right + upVec.y * up) * speed;
-        this.camera.target.z += (dir.z * forward + rightVec.z * right + upVec.z * up) * speed;
-        this.updateMatrices();
+        this.animator.moveFirstPerson(forward, right, up);
     }
     /**
      * Set preset view with explicit bounds (Y-up coordinate system)
-     * Clicking the same view again rotates 90° around the view axis
+     * 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.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° - North up
-            { x: -1, y: 0, z: 0 }, // 90° - West up
-            { x: 0, y: 0, z: 1 }, // 180° - South up
-            { x: 1, y: 0, z: 0 }, // 270° - East up
-        ];
-        const bottomUpVectors = [
-            { x: 0, y: 0, z: 1 }, // 0° - South up
-            { x: 1, y: 0, z: 0 }, // 90° - East up
-            { x: 0, y: 0, z: -1 }, // 180° - North up
-            { x: -1, y: 0, z: 0 }, // 270° - 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: looking straight down from above (+Y)
-                // Counter-rotate up vector by NEGATIVE building rotation to align with building axes
-                const topUp = topUpVectors[this.presetViewRotation];
-                endPos = { x: center.x, y: center.y + distance, z: center.z };
-                upVector = {
-                    x: topUp.x * cosR + topUp.z * sinR,
-                    y: topUp.y,
-                    z: -topUp.x * sinR + topUp.z * cosR,
-                };
-                break;
-            case 'bottom':
-                // Bottom view: looking straight up from below (-Y)
-                // Counter-rotate up vector by NEGATIVE building rotation to align with building axes
-                const bottomUp = bottomUpVectors[this.presetViewRotation];
-                endPos = { x: center.x, y: center.y - distance, z: center.z };
-                upVector = {
-                    x: bottomUp.x * cosR + bottomUp.z * sinR,
-                    y: bottomUp.y,
-                    z: -bottomUp.x * sinR + bottomUp.z * cosR,
-                };
-                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.camera.position.x - this.camera.target.x,
-            y: this.camera.position.y - this.camera.target.y,
-            z: this.camera.position.z - this.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.camera.target.x - size,
-                y: this.camera.target.y - size,
-                z: this.camera.target.z - size,
-            },
-            max: {
-                x: this.camera.target.x + size,
-                y: this.camera.target.y + size,
-                z: this.camera.target.z + size,
-            },
-        };
+        this.animator.setPresetView(view, bounds, buildingRotation);
     }
     /**
      * Reset velocity (stop inertia)
      */
     stopInertia() {
-        this.velocity.orbit.x = 0;
-        this.velocity.orbit.y = 0;
-        this.velocity.pan.x = 0;
-        this.velocity.pan.y = 0;
-        this.velocity.zoom = 0;
+        this.animator.stopInertia();
     }
     /**
      * Reset camera state (clear orbit pivot, stop inertia, cancel animations)
      * Called when loading a new model to ensure clean state
      */
     reset() {
-        this.orbitPivot = null;
-        this.stopInertia();
-        // Cancel any ongoing animations
-        this.animationStartTime = 0;
-        this.animationDuration = 0;
-        this.animationStartPos = null;
-        this.animationStartTarget = null;
-        this.animationEndPos = null;
-        this.animationEndTarget = null;
-        this.animationStartUp = null;
-        this.animationEndUp = null;
-        this.animationEasing = null;
-        // Reset preset view tracking
-        this.lastPresetView = null;
-        this.presetViewRotation = 0;
+        this.controls.clearOrbitPivot();
+        this.animator.reset();
     }
     getViewProjMatrix() {
-        return this.viewProjMatrix;
+        return this.state.viewProjMatrix;
     }
     getPosition() {
-        return { ...this.camera.position };
+        return { ...this.state.camera.position };
     }
     getTarget() {
-        return { ...this.camera.target };
+        return { ...this.state.camera.target };
     }
     /**
      * Get camera up vector
      */
     getUp() {
-        return { ...this.camera.up };
+        return { ...this.state.camera.up };
     }
     /**
      * Get camera FOV in radians
      */
     getFOV() {
-        return this.camera.fov;
+        return this.state.camera.fov;
     }
     /**
      * Get distance from camera position to target
      */
     getDistance() {
         const dir = {
-            x: this.camera.position.x - this.camera.target.x,
-            y: this.camera.position.y - this.camera.target.y,
-            z: this.camera.position.z - this.camera.target.z,
+            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,
         };
         return Math.sqrt(dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
     }
@@ -905,9 +237,9 @@ export class Camera {
      */
     getRotation() {
         const dir = {
-            x: this.camera.position.x - this.camera.target.x,
-            y: this.camera.position.y - this.camera.target.y,
-            z: this.camera.position.z - this.camera.target.z,
+            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);
         if (distance < 1e-6)
@@ -916,9 +248,9 @@ export class Camera {
         const elevation = Math.asin(Math.max(-1, Math.min(1, dir.y / distance))) * 180 / Math.PI;
         // Calculate azimuth smoothly using up vector
         // The up vector defines the "screen up" direction, which determines rotation
-        const upX = this.camera.up.x;
-        const upY = this.camera.up.y;
-        const upZ = this.camera.up.z;
+        const upX = this.state.camera.up.x;
+        const upY = this.state.camera.up.y;
+        const upZ = this.state.camera.up.z;
         // Project up vector onto horizontal plane (XZ plane)
         const upLen = Math.sqrt(upX * upX + upZ * upZ);
         let azimuth;
@@ -936,13 +268,6 @@ export class Camera {
         }
         return { azimuth, elevation };
     }
-    /**
-     * Project a world position to screen coordinates
-     * @param worldPos - Position in world space
-     * @param canvasWidth - Canvas width in pixels
-     * @param canvasHeight - Canvas height in pixels
-     * @returns Screen coordinates { x, y } or null if behind camera
-     */
     /**
      * Unproject screen coordinates to a ray in world space
      * @param screenX - X position in screen coordinates
@@ -952,83 +277,71 @@ export class Camera {
      * @returns Ray origin and direction in world space
      */
     unprojectToRay(screenX, screenY, canvasWidth, canvasHeight) {
-        // For perspective camera, ray origin is always the camera position
-        // Direction is computed through the screen point
-        // Convert screen coords to NDC (-1 to 1)
-        const ndcX = (screenX / canvasWidth) * 2 - 1;
-        const ndcY = 1 - (screenY / canvasHeight) * 2; // Flip Y
-        // Invert the view-projection matrix
-        const invViewProj = MathUtils.invert(this.viewProjMatrix);
-        if (!invViewProj) {
-            // Fallback: return ray from camera position towards target
-            const dir = MathUtils.normalize({
-                x: this.camera.target.x - this.camera.position.x,
-                y: this.camera.target.y - this.camera.position.y,
-                z: this.camera.target.z - this.camera.position.z,
-            });
-            return { origin: { ...this.camera.position }, direction: dir };
-        }
-        // Unproject a point at some depth to get a point on the ray
-        // Using z=0.5 (midpoint in Reverse-Z: 1.0=near, 0.0=far) to get a finite point
-        const worldPoint = MathUtils.transformPoint(invViewProj, { x: ndcX, y: ndcY, z: 0.5 });
-        // Ray origin is camera position, direction is towards unprojected point
-        const origin = { ...this.camera.position };
-        const direction = MathUtils.normalize({
-            x: worldPoint.x - origin.x,
-            y: worldPoint.y - origin.y,
-            z: worldPoint.z - origin.z,
-        });
-        return { origin, direction };
+        return this.projection.unprojectToRay(screenX, screenY, canvasWidth, canvasHeight);
     }
+    /**
+     * Project a world position to screen coordinates
+     * @param worldPos - Position in world space
+     * @param canvasWidth - Canvas width in pixels
+     * @param canvasHeight - Canvas height in pixels
+     * @returns Screen coordinates { x, y } or null if behind camera
+     */
     projectToScreen(worldPos, canvasWidth, canvasHeight) {
-        // Transform world position by view-projection matrix
-        const m = this.viewProjMatrix.m;
-        // Manual matrix-vector multiplication for vec4(worldPos, 1.0)
-        const clipX = m[0] * worldPos.x + m[4] * worldPos.y + m[8] * worldPos.z + m[12];
-        const clipY = m[1] * worldPos.x + m[5] * worldPos.y + m[9] * worldPos.z + m[13];
-        const clipZ = m[2] * worldPos.x + m[6] * worldPos.y + m[10] * worldPos.z + m[14];
-        const clipW = m[3] * worldPos.x + m[7] * worldPos.y + m[11] * worldPos.z + m[15];
-        // Check if behind camera
-        if (clipW <= 0) {
-            return null;
-        }
-        // Perspective divide to get NDC
-        const ndcX = clipX / clipW;
-        const ndcY = clipY / clipW;
-        const ndcZ = clipZ / clipW;
-        // Check if outside clip volume
-        if (ndcZ < -1 || ndcZ > 1) {
-            return null;
+        return this.projection.projectToScreen(worldPos, canvasWidth, canvasHeight);
+    }
+    /**
+     * Set projection mode (perspective or orthographic)
+     * When switching to orthographic, calculates initial orthoSize from current view.
+     */
+    setProjectionMode(mode) {
+        if (this.state.projectionMode === mode)
+            return;
+        if (mode === 'orthographic') {
+            // Calculate orthoSize from current perspective view so the model appears the same size
+            const distance = this.getDistance();
+            this.state.orthoSize = distance * Math.tan(this.state.camera.fov / 2);
         }
-        // Convert NDC to screen coordinates
-        // NDC: (-1,-1) = bottom-left, (1,1) = top-right
-        // Screen: (0,0) = top-left, (width, height) = bottom-right
-        const screenX = (ndcX + 1) * 0.5 * canvasWidth;
-        const screenY = (1 - ndcY) * 0.5 * canvasHeight; // Flip Y
-        return { x: screenX, y: screenY };
+        this.state.projectionMode = mode;
+        this.updateMatrices();
+    }
+    /**
+     * Toggle between perspective and orthographic projection
+     */
+    toggleProjectionMode() {
+        this.setProjectionMode(this.state.projectionMode === 'perspective' ? 'orthographic' : 'perspective');
     }
     /**
-     * Update near/far planes dynamically based on camera distance
-     * Keeps ratio under 10000:1 to prevent Z-fighting
+     * Get current projection mode
      */
-    updateNearFarPlanes(distance) {
-        const optimalNear = Math.max(0.01, distance * 0.001); // 0.1% of distance
-        const optimalFar = distance * 10; // 10x distance for safety margin
-        // Ensure ratio is reasonable (max 10000:1)
-        const maxRatio = 10000;
-        if (optimalFar / optimalNear > maxRatio) {
-            this.camera.far = optimalNear * maxRatio;
+    getProjectionMode() {
+        return this.state.projectionMode;
+    }
+    /**
+     * Get orthographic view half-height
+     */
+    getOrthoSize() {
+        return this.state.orthoSize;
+    }
+    updateMatrices() {
+        // Dynamically adapt near/far planes based on camera-to-target distance.
+        // This prevents near-plane clipping when zooming in close to geometry.
+        const dx = this.state.camera.position.x - this.state.camera.target.x;
+        const dy = this.state.camera.position.y - this.state.camera.target.y;
+        const dz = this.state.camera.position.z - this.state.camera.target.z;
+        const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        this.state.camera.near = Math.max(0.01, distance * 0.001);
+        this.state.camera.far = Math.max(distance * 10, 1000);
+        this.state.viewMatrix = MathUtils.lookAt(this.state.camera.position, this.state.camera.target, this.state.camera.up);
+        if (this.state.projectionMode === 'orthographic') {
+            const h = this.state.orthoSize;
+            const w = h * this.state.camera.aspect;
+            this.state.projMatrix = MathUtils.orthographicReverseZ(-w, w, -h, h, this.state.camera.near, this.state.camera.far);
         }
         else {
-            this.camera.far = Math.max(optimalFar, this.camera.far);
+            // Use reverse-Z projection for better depth precision
+            this.state.projMatrix = MathUtils.perspectiveReverseZ(this.state.camera.fov, this.state.camera.aspect, this.state.camera.near, this.state.camera.far);
         }
-        this.camera.near = Math.min(optimalNear, this.camera.near);
-    }
-    updateMatrices() {
-        this.viewMatrix = MathUtils.lookAt(this.camera.position, this.camera.target, this.camera.up);
-        // Use reverse-Z projection for better depth precision
-        this.projMatrix = MathUtils.perspectiveReverseZ(this.camera.fov, this.camera.aspect, this.camera.near, this.camera.far);
-        this.viewProjMatrix = MathUtils.multiply(this.projMatrix, this.viewMatrix);
+        this.state.viewProjMatrix = MathUtils.multiply(this.state.projMatrix, this.state.viewMatrix);
     }
 }
 //# sourceMappingURL=camera.js.map