@spiffcommerce/preview 3.6.2-rc.8 → 4.0.0

package/dist/productCamera.esm2.js

@@ -1,3870 +0,0 @@
-import { O as Observable, V as Vector3, b as Vector2, M as Matrix, _ as __decorate, Q as Quaternion, T as TmpVectors, d as serializeAsVector3, s as serialize, c as serializeAsMeshReference, S as SerializationHelper, h as serializeAsVector2 } from './webRequest.esm.js';
-import { N as Node } from './node.esm.js';
-import { M as Mesh } from './mesh.esm.js';
-import { l as PointerEventTypes, m as PrecisionDate, L as Logger, c as Tools, K as KeyboardEventTypes, n as EventConstants, P as Plane } from './engine.esm.js';
-import { E as Epsilon, S as Scalar } from './math.color.esm.js';
-import { B as BackEase, E as EasingFunction, a as ExponentialEase } from './easing.esm.js';
-import { A as Animation } from './animation.esm.js';
-import { C as Camera } from './material.esm2.js';
-import { A as Axis } from './math.axis.esm.js';
-
-/**
- * The autoRotation behavior (AutoRotationBehavior) is designed to create a smooth rotation of an ArcRotateCamera when there is no user interaction.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/behaviors/cameraBehaviors#autorotation-behavior
- */
-class AutoRotationBehavior {
-    constructor() {
-        this._zoomStopsAnimation = false;
-        this._idleRotationSpeed = 0.05;
-        this._idleRotationWaitTime = 2000;
-        this._idleRotationSpinupTime = 2000;
-        this.targetAlpha = null;
-        this._isPointerDown = false;
-        this._lastFrameTime = null;
-        this._lastInteractionTime = -Infinity;
-        this._cameraRotationSpeed = 0;
-        this._lastFrameRadius = 0;
-    }
-    /**
-     * Gets the name of the behavior.
-     */
-    get name() {
-        return "AutoRotation";
-    }
-    /**
-     * Sets the flag that indicates if user zooming should stop animation.
-     */
-    set zoomStopsAnimation(flag) {
-        this._zoomStopsAnimation = flag;
-    }
-    /**
-     * Gets the flag that indicates if user zooming should stop animation.
-     */
-    get zoomStopsAnimation() {
-        return this._zoomStopsAnimation;
-    }
-    /**
-     * Sets the default speed at which the camera rotates around the model.
-     */
-    set idleRotationSpeed(speed) {
-        this._idleRotationSpeed = speed;
-    }
-    /**
-     * Gets the default speed at which the camera rotates around the model.
-     */
-    get idleRotationSpeed() {
-        return this._idleRotationSpeed;
-    }
-    /**
-     * Sets the time (in milliseconds) to wait after user interaction before the camera starts rotating.
-     */
-    set idleRotationWaitTime(time) {
-        this._idleRotationWaitTime = time;
-    }
-    /**
-     * Gets the time (milliseconds) to wait after user interaction before the camera starts rotating.
-     */
-    get idleRotationWaitTime() {
-        return this._idleRotationWaitTime;
-    }
-    /**
-     * Sets the time (milliseconds) to take to spin up to the full idle rotation speed.
-     */
-    set idleRotationSpinupTime(time) {
-        this._idleRotationSpinupTime = time;
-    }
-    /**
-     * Gets the time (milliseconds) to take to spin up to the full idle rotation speed.
-     */
-    get idleRotationSpinupTime() {
-        return this._idleRotationSpinupTime;
-    }
-    /**
-     * Gets a value indicating if the camera is currently rotating because of this behavior
-     */
-    get rotationInProgress() {
-        return Math.abs(this._cameraRotationSpeed) > 0;
-    }
-    /**
-     * Initializes the behavior.
-     */
-    init() {
-        // Do nothing
-    }
-    /**
-     * Attaches the behavior to its arc rotate camera.
-     * @param camera Defines the camera to attach the behavior to
-     */
-    attach(camera) {
-        this._attachedCamera = camera;
-        const scene = this._attachedCamera.getScene();
-        this._onPrePointerObservableObserver = scene.onPrePointerObservable.add((pointerInfoPre) => {
-            if (pointerInfoPre.type === PointerEventTypes.POINTERDOWN) {
-                this._isPointerDown = true;
-                return;
-            }
-            if (pointerInfoPre.type === PointerEventTypes.POINTERUP) {
-                this._isPointerDown = false;
-            }
-        });
-        this._onAfterCheckInputsObserver = camera.onAfterCheckInputsObservable.add(() => {
-            if (this._reachTargetAlpha()) {
-                return;
-            }
-            const now = PrecisionDate.Now;
-            let dt = 0;
-            if (this._lastFrameTime != null) {
-                dt = now - this._lastFrameTime;
-            }
-            this._lastFrameTime = now;
-            // Stop the animation if there is user interaction and the animation should stop for this interaction
-            this._applyUserInteraction();
-            const timeToRotation = now - this._lastInteractionTime - this._idleRotationWaitTime;
-            const scale = Math.max(Math.min(timeToRotation / this._idleRotationSpinupTime, 1), 0);
-            this._cameraRotationSpeed = this._idleRotationSpeed * scale;
-            // Step camera rotation by rotation speed
-            if (this._attachedCamera) {
-                this._attachedCamera.alpha -= this._cameraRotationSpeed * (dt / 1000);
-            }
-        });
-    }
-    /**
-     * Detaches the behavior from its current arc rotate camera.
-     */
-    detach() {
-        if (!this._attachedCamera) {
-            return;
-        }
-        const scene = this._attachedCamera.getScene();
-        if (this._onPrePointerObservableObserver) {
-            scene.onPrePointerObservable.remove(this._onPrePointerObservableObserver);
-        }
-        this._attachedCamera.onAfterCheckInputsObservable.remove(this._onAfterCheckInputsObserver);
-        this._attachedCamera = null;
-    }
-    /**
-     * Force-reset the last interaction time
-     * @param customTime an optional time that will be used instead of the current last interaction time. For example `Date.now()`
-     */
-    resetLastInteractionTime(customTime) {
-        this._lastInteractionTime = customTime !== null && customTime !== void 0 ? customTime : PrecisionDate.Now;
-    }
-    /**
-     * Returns true if camera alpha reaches the target alpha
-     * @returns true if camera alpha reaches the target alpha
-     */
-    _reachTargetAlpha() {
-        if (this._attachedCamera && this.targetAlpha) {
-            return Math.abs(this._attachedCamera.alpha - this.targetAlpha) < Epsilon;
-        }
-        return false;
-    }
-    /**
-     * Returns true if user is scrolling.
-     * @returns true if user is scrolling.
-     */
-    _userIsZooming() {
-        if (!this._attachedCamera) {
-            return false;
-        }
-        return this._attachedCamera.inertialRadiusOffset !== 0;
-    }
-    _shouldAnimationStopForInteraction() {
-        if (!this._attachedCamera) {
-            return false;
-        }
-        let zoomHasHitLimit = false;
-        if (this._lastFrameRadius === this._attachedCamera.radius && this._attachedCamera.inertialRadiusOffset !== 0) {
-            zoomHasHitLimit = true;
-        }
-        // Update the record of previous radius - works as an approx. indicator of hitting radius limits
-        this._lastFrameRadius = this._attachedCamera.radius;
-        return this._zoomStopsAnimation ? zoomHasHitLimit : this._userIsZooming();
-    }
-    /**
-     *  Applies any current user interaction to the camera. Takes into account maximum alpha rotation.
-     */
-    _applyUserInteraction() {
-        if (this._userIsMoving() && !this._shouldAnimationStopForInteraction()) {
-            this._lastInteractionTime = PrecisionDate.Now;
-        }
-    }
-    // Tools
-    _userIsMoving() {
-        if (!this._attachedCamera) {
-            return false;
-        }
-        return (this._attachedCamera.inertialAlphaOffset !== 0 ||
-            this._attachedCamera.inertialBetaOffset !== 0 ||
-            this._attachedCamera.inertialRadiusOffset !== 0 ||
-            this._attachedCamera.inertialPanningX !== 0 ||
-            this._attachedCamera.inertialPanningY !== 0 ||
-            this._isPointerDown);
-    }
-}
-
-/**
- * Add a bouncing effect to an ArcRotateCamera when reaching a specified minimum and maximum radius
- * @see https://doc.babylonjs.com/features/featuresDeepDive/behaviors/cameraBehaviors#bouncing-behavior
- */
-class BouncingBehavior {
-    constructor() {
-        /**
-         * The duration of the animation, in milliseconds
-         */
-        this.transitionDuration = 450;
-        /**
-         * Length of the distance animated by the transition when lower radius is reached
-         */
-        this.lowerRadiusTransitionRange = 2;
-        /**
-         * Length of the distance animated by the transition when upper radius is reached
-         */
-        this.upperRadiusTransitionRange = -2;
-        this._autoTransitionRange = false;
-        // Animations
-        this._radiusIsAnimating = false;
-        this._radiusBounceTransition = null;
-        this._animatables = new Array();
-    }
-    /**
-     * Gets the name of the behavior.
-     */
-    get name() {
-        return "Bouncing";
-    }
-    /**
-     * Gets a value indicating if the lowerRadiusTransitionRange and upperRadiusTransitionRange are defined automatically
-     */
-    get autoTransitionRange() {
-        return this._autoTransitionRange;
-    }
-    /**
-     * Sets a value indicating if the lowerRadiusTransitionRange and upperRadiusTransitionRange are defined automatically
-     * Transition ranges will be set to 5% of the bounding box diagonal in world space
-     */
-    set autoTransitionRange(value) {
-        if (this._autoTransitionRange === value) {
-            return;
-        }
-        this._autoTransitionRange = value;
-        const camera = this._attachedCamera;
-        if (!camera) {
-            return;
-        }
-        if (value) {
-            this._onMeshTargetChangedObserver = camera.onMeshTargetChangedObservable.add((mesh) => {
-                if (!mesh) {
-                    return;
-                }
-                mesh.computeWorldMatrix(true);
-                const diagonal = mesh.getBoundingInfo().diagonalLength;
-                this.lowerRadiusTransitionRange = diagonal * 0.05;
-                this.upperRadiusTransitionRange = diagonal * 0.05;
-            });
-        }
-        else if (this._onMeshTargetChangedObserver) {
-            camera.onMeshTargetChangedObservable.remove(this._onMeshTargetChangedObserver);
-        }
-    }
-    /**
-     * Initializes the behavior.
-     */
-    init() {
-        // Do nothing
-    }
-    /**
-     * Attaches the behavior to its arc rotate camera.
-     * @param camera Defines the camera to attach the behavior to
-     */
-    attach(camera) {
-        this._attachedCamera = camera;
-        this._onAfterCheckInputsObserver = camera.onAfterCheckInputsObservable.add(() => {
-            if (!this._attachedCamera) {
-                return;
-            }
-            // Add the bounce animation to the lower radius limit
-            if (this._isRadiusAtLimit(this._attachedCamera.lowerRadiusLimit)) {
-                this._applyBoundRadiusAnimation(this.lowerRadiusTransitionRange);
-            }
-            // Add the bounce animation to the upper radius limit
-            if (this._isRadiusAtLimit(this._attachedCamera.upperRadiusLimit)) {
-                this._applyBoundRadiusAnimation(this.upperRadiusTransitionRange);
-            }
-        });
-    }
-    /**
-     * Detaches the behavior from its current arc rotate camera.
-     */
-    detach() {
-        if (!this._attachedCamera) {
-            return;
-        }
-        if (this._onAfterCheckInputsObserver) {
-            this._attachedCamera.onAfterCheckInputsObservable.remove(this._onAfterCheckInputsObserver);
-        }
-        if (this._onMeshTargetChangedObserver) {
-            this._attachedCamera.onMeshTargetChangedObservable.remove(this._onMeshTargetChangedObserver);
-        }
-        this._attachedCamera = null;
-    }
-    /**
-     * Checks if the camera radius is at the specified limit. Takes into account animation locks.
-     * @param radiusLimit The limit to check against.
-     * @returns Bool to indicate if at limit.
-     */
-    _isRadiusAtLimit(radiusLimit) {
-        if (!this._attachedCamera) {
-            return false;
-        }
-        if (this._attachedCamera.radius === radiusLimit && !this._radiusIsAnimating) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Applies an animation to the radius of the camera, extending by the radiusDelta.
-     * @param radiusDelta The delta by which to animate to. Can be negative.
-     */
-    _applyBoundRadiusAnimation(radiusDelta) {
-        if (!this._attachedCamera) {
-            return;
-        }
-        if (!this._radiusBounceTransition) {
-            BouncingBehavior.EasingFunction.setEasingMode(BouncingBehavior.EasingMode);
-            this._radiusBounceTransition = Animation.CreateAnimation("radius", Animation.ANIMATIONTYPE_FLOAT, 60, BouncingBehavior.EasingFunction);
-        }
-        // Prevent zoom until bounce has completed
-        this._cachedWheelPrecision = this._attachedCamera.wheelPrecision;
-        this._attachedCamera.wheelPrecision = Infinity;
-        this._attachedCamera.inertialRadiusOffset = 0;
-        // Animate to the radius limit
-        this.stopAllAnimations();
-        this._radiusIsAnimating = true;
-        const animatable = Animation.TransitionTo("radius", this._attachedCamera.radius + radiusDelta, this._attachedCamera, this._attachedCamera.getScene(), 60, this._radiusBounceTransition, this.transitionDuration, () => this._clearAnimationLocks());
-        if (animatable) {
-            this._animatables.push(animatable);
-        }
-    }
-    /**
-     * Removes all animation locks. Allows new animations to be added to any of the camera properties.
-     */
-    _clearAnimationLocks() {
-        this._radiusIsAnimating = false;
-        if (this._attachedCamera) {
-            this._attachedCamera.wheelPrecision = this._cachedWheelPrecision;
-        }
-    }
-    /**
-     * Stops and removes all animations that have been applied to the camera
-     */
-    stopAllAnimations() {
-        if (this._attachedCamera) {
-            this._attachedCamera.animations = [];
-        }
-        while (this._animatables.length) {
-            this._animatables[0].onAnimationEnd = null;
-            this._animatables[0].stop();
-            this._animatables.shift();
-        }
-    }
-}
-/**
- * The easing function used by animations
- */
-BouncingBehavior.EasingFunction = new BackEase(0.3);
-/**
- * The easing mode used by animations
- */
-BouncingBehavior.EasingMode = EasingFunction.EASINGMODE_EASEOUT;
-
-/**
- * The framing behavior (FramingBehavior) is designed to automatically position an ArcRotateCamera when its target is set to a mesh. It is also useful if you want to prevent the camera to go under a virtual horizontal plane.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/behaviors/cameraBehaviors#framing-behavior
- */
-class FramingBehavior {
-    constructor() {
-        /**
-         * An event triggered when the animation to zoom on target mesh has ended
-         */
-        this.onTargetFramingAnimationEndObservable = new Observable();
-        this._mode = FramingBehavior.FitFrustumSidesMode;
-        this._radiusScale = 1.0;
-        this._positionScale = 0.5;
-        this._defaultElevation = 0.3;
-        this._elevationReturnTime = 1500;
-        this._elevationReturnWaitTime = 1000;
-        this._zoomStopsAnimation = false;
-        this._framingTime = 1500;
-        /**
-         * Define if the behavior should automatically change the configured
-         * camera limits and sensibilities.
-         */
-        this.autoCorrectCameraLimitsAndSensibility = true;
-        this._isPointerDown = false;
-        this._lastInteractionTime = -Infinity;
-        // Framing control
-        this._animatables = new Array();
-        this._betaIsAnimating = false;
-    }
-    /**
-     * Gets the name of the behavior.
-     */
-    get name() {
-        return "Framing";
-    }
-    /**
-     * Sets the current mode used by the behavior
-     */
-    set mode(mode) {
-        this._mode = mode;
-    }
-    /**
-     * Gets current mode used by the behavior.
-     */
-    get mode() {
-        return this._mode;
-    }
-    /**
-     * Sets the scale applied to the radius (1 by default)
-     */
-    set radiusScale(radius) {
-        this._radiusScale = radius;
-    }
-    /**
-     * Gets the scale applied to the radius
-     */
-    get radiusScale() {
-        return this._radiusScale;
-    }
-    /**
-     * Sets the scale to apply on Y axis to position camera focus. 0.5 by default which means the center of the bounding box.
-     */
-    set positionScale(scale) {
-        this._positionScale = scale;
-    }
-    /**
-     * Gets the scale to apply on Y axis to position camera focus. 0.5 by default which means the center of the bounding box.
-     */
-    get positionScale() {
-        return this._positionScale;
-    }
-    /**
-     * Sets the angle above/below the horizontal plane to return to when the return to default elevation idle
-     * behaviour is triggered, in radians.
-     */
-    set defaultElevation(elevation) {
-        this._defaultElevation = elevation;
-    }
-    /**
-     * Gets the angle above/below the horizontal plane to return to when the return to default elevation idle
-     * behaviour is triggered, in radians.
-     */
-    get defaultElevation() {
-        return this._defaultElevation;
-    }
-    /**
-     * Sets the time (in milliseconds) taken to return to the default beta position.
-     * Negative value indicates camera should not return to default.
-     */
-    set elevationReturnTime(speed) {
-        this._elevationReturnTime = speed;
-    }
-    /**
-     * Gets the time (in milliseconds) taken to return to the default beta position.
-     * Negative value indicates camera should not return to default.
-     */
-    get elevationReturnTime() {
-        return this._elevationReturnTime;
-    }
-    /**
-     * Sets the delay (in milliseconds) taken before the camera returns to the default beta position.
-     */
-    set elevationReturnWaitTime(time) {
-        this._elevationReturnWaitTime = time;
-    }
-    /**
-     * Gets the delay (in milliseconds) taken before the camera returns to the default beta position.
-     */
-    get elevationReturnWaitTime() {
-        return this._elevationReturnWaitTime;
-    }
-    /**
-     * Sets the flag that indicates if user zooming should stop animation.
-     */
-    set zoomStopsAnimation(flag) {
-        this._zoomStopsAnimation = flag;
-    }
-    /**
-     * Gets the flag that indicates if user zooming should stop animation.
-     */
-    get zoomStopsAnimation() {
-        return this._zoomStopsAnimation;
-    }
-    /**
-     * Sets the transition time when framing the mesh, in milliseconds
-     */
-    set framingTime(time) {
-        this._framingTime = time;
-    }
-    /**
-     * Gets the transition time when framing the mesh, in milliseconds
-     */
-    get framingTime() {
-        return this._framingTime;
-    }
-    /**
-     * Initializes the behavior.
-     */
-    init() {
-        // Do nothing
-    }
-    /**
-     * Attaches the behavior to its arc rotate camera.
-     * @param camera Defines the camera to attach the behavior to
-     */
-    attach(camera) {
-        this._attachedCamera = camera;
-        const scene = this._attachedCamera.getScene();
-        FramingBehavior.EasingFunction.setEasingMode(FramingBehavior.EasingMode);
-        this._onPrePointerObservableObserver = scene.onPrePointerObservable.add((pointerInfoPre) => {
-            if (pointerInfoPre.type === PointerEventTypes.POINTERDOWN) {
-                this._isPointerDown = true;
-                return;
-            }
-            if (pointerInfoPre.type === PointerEventTypes.POINTERUP) {
-                this._isPointerDown = false;
-            }
-        });
-        this._onMeshTargetChangedObserver = camera.onMeshTargetChangedObservable.add((mesh) => {
-            if (mesh) {
-                this.zoomOnMesh(mesh, undefined, () => {
-                    this.onTargetFramingAnimationEndObservable.notifyObservers();
-                });
-            }
-        });
-        this._onAfterCheckInputsObserver = camera.onAfterCheckInputsObservable.add(() => {
-            // Stop the animation if there is user interaction and the animation should stop for this interaction
-            this._applyUserInteraction();
-            // Maintain the camera above the ground. If the user pulls the camera beneath the ground plane, lift it
-            // back to the default position after a given timeout
-            this._maintainCameraAboveGround();
-        });
-    }
-    /**
-     * Detaches the behavior from its current arc rotate camera.
-     */
-    detach() {
-        if (!this._attachedCamera) {
-            return;
-        }
-        const scene = this._attachedCamera.getScene();
-        if (this._onPrePointerObservableObserver) {
-            scene.onPrePointerObservable.remove(this._onPrePointerObservableObserver);
-        }
-        if (this._onAfterCheckInputsObserver) {
-            this._attachedCamera.onAfterCheckInputsObservable.remove(this._onAfterCheckInputsObserver);
-        }
-        if (this._onMeshTargetChangedObserver) {
-            this._attachedCamera.onMeshTargetChangedObservable.remove(this._onMeshTargetChangedObserver);
-        }
-        this._attachedCamera = null;
-    }
-    /**
-     * Targets the given mesh and updates zoom level accordingly.
-     * @param mesh  The mesh to target.
-     * @param focusOnOriginXZ Determines if the camera should focus on 0 in the X and Z axis instead of the mesh
-     * @param onAnimationEnd Callback triggered at the end of the framing animation
-     */
-    zoomOnMesh(mesh, focusOnOriginXZ = false, onAnimationEnd = null) {
-        mesh.computeWorldMatrix(true);
-        const boundingBox = mesh.getBoundingInfo().boundingBox;
-        this.zoomOnBoundingInfo(boundingBox.minimumWorld, boundingBox.maximumWorld, focusOnOriginXZ, onAnimationEnd);
-    }
-    /**
-     * Targets the given mesh with its children and updates zoom level accordingly.
-     * @param mesh  The mesh to target.
-     * @param focusOnOriginXZ Determines if the camera should focus on 0 in the X and Z axis instead of the mesh
-     * @param onAnimationEnd Callback triggered at the end of the framing animation
-     */
-    zoomOnMeshHierarchy(mesh, focusOnOriginXZ = false, onAnimationEnd = null) {
-        mesh.computeWorldMatrix(true);
-        const boundingBox = mesh.getHierarchyBoundingVectors(true);
-        this.zoomOnBoundingInfo(boundingBox.min, boundingBox.max, focusOnOriginXZ, onAnimationEnd);
-    }
-    /**
-     * Targets the given meshes with their children and updates zoom level accordingly.
-     * @param meshes  The mesh to target.
-     * @param focusOnOriginXZ Determines if the camera should focus on 0 in the X and Z axis instead of the mesh
-     * @param onAnimationEnd Callback triggered at the end of the framing animation
-     */
-    zoomOnMeshesHierarchy(meshes, focusOnOriginXZ = false, onAnimationEnd = null) {
-        const min = new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-        const max = new Vector3(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
-        for (let i = 0; i < meshes.length; i++) {
-            const boundingInfo = meshes[i].getHierarchyBoundingVectors(true);
-            Vector3.CheckExtends(boundingInfo.min, min, max);
-            Vector3.CheckExtends(boundingInfo.max, min, max);
-        }
-        this.zoomOnBoundingInfo(min, max, focusOnOriginXZ, onAnimationEnd);
-    }
-    /**
-     * Targets the bounding box info defined by its extends and updates zoom level accordingly.
-     * @param minimumWorld Determines the smaller position of the bounding box extend
-     * @param maximumWorld Determines the bigger position of the bounding box extend
-     * @param focusOnOriginXZ Determines if the camera should focus on 0 in the X and Z axis instead of the mesh
-     * @param onAnimationEnd Callback triggered at the end of the framing animation
-     */
-    zoomOnBoundingInfo(minimumWorld, maximumWorld, focusOnOriginXZ = false, onAnimationEnd = null) {
-        let zoomTarget;
-        if (!this._attachedCamera) {
-            return;
-        }
-        // Find target by interpolating from bottom of bounding box in world-space to top via framingPositionY
-        const bottom = minimumWorld.y;
-        const top = maximumWorld.y;
-        const zoomTargetY = bottom + (top - bottom) * this._positionScale;
-        const radiusWorld = maximumWorld.subtract(minimumWorld).scale(0.5);
-        if (focusOnOriginXZ) {
-            zoomTarget = new Vector3(0, zoomTargetY, 0);
-        }
-        else {
-            const centerWorld = minimumWorld.add(radiusWorld);
-            zoomTarget = new Vector3(centerWorld.x, zoomTargetY, centerWorld.z);
-        }
-        if (!this._vectorTransition) {
-            this._vectorTransition = Animation.CreateAnimation("target", Animation.ANIMATIONTYPE_VECTOR3, 60, FramingBehavior.EasingFunction);
-        }
-        this._betaIsAnimating = true;
-        let animatable = Animation.TransitionTo("target", zoomTarget, this._attachedCamera, this._attachedCamera.getScene(), 60, this._vectorTransition, this._framingTime);
-        if (animatable) {
-            this._animatables.push(animatable);
-        }
-        // sets the radius and lower radius bounds
-        // Small delta ensures camera is not always at lower zoom limit.
-        let radius = 0;
-        if (this._mode === FramingBehavior.FitFrustumSidesMode) {
-            const position = this._calculateLowerRadiusFromModelBoundingSphere(minimumWorld, maximumWorld);
-            if (this.autoCorrectCameraLimitsAndSensibility) {
-                this._attachedCamera.lowerRadiusLimit = radiusWorld.length() + this._attachedCamera.minZ;
-            }
-            radius = position;
-        }
-        else if (this._mode === FramingBehavior.IgnoreBoundsSizeMode) {
-            radius = this._calculateLowerRadiusFromModelBoundingSphere(minimumWorld, maximumWorld);
-            if (this.autoCorrectCameraLimitsAndSensibility && this._attachedCamera.lowerRadiusLimit === null) {
-                this._attachedCamera.lowerRadiusLimit = this._attachedCamera.minZ;
-            }
-        }
-        // Set sensibilities
-        if (this.autoCorrectCameraLimitsAndSensibility) {
-            const extend = maximumWorld.subtract(minimumWorld).length();
-            this._attachedCamera.panningSensibility = 5000 / extend;
-            this._attachedCamera.wheelPrecision = 100 / radius;
-        }
-        // transition to new radius
-        if (!this._radiusTransition) {
-            this._radiusTransition = Animation.CreateAnimation("radius", Animation.ANIMATIONTYPE_FLOAT, 60, FramingBehavior.EasingFunction);
-        }
-        animatable = Animation.TransitionTo("radius", radius, this._attachedCamera, this._attachedCamera.getScene(), 60, this._radiusTransition, this._framingTime, () => {
-            this.stopAllAnimations();
-            if (onAnimationEnd) {
-                onAnimationEnd();
-            }
-            if (this._attachedCamera && this._attachedCamera.useInputToRestoreState) {
-                this._attachedCamera.storeState();
-            }
-        });
-        if (animatable) {
-            this._animatables.push(animatable);
-        }
-    }
-    /**
-     * Calculates the lowest radius for the camera based on the bounding box of the mesh.
-     * @param minimumWorld
-     * @param maximumWorld
-     * @returns The minimum distance from the primary mesh's center point at which the camera must be kept in order
-     *		 to fully enclose the mesh in the viewing frustum.
-     */
-    _calculateLowerRadiusFromModelBoundingSphere(minimumWorld, maximumWorld) {
-        const size = maximumWorld.subtract(minimumWorld);
-        const boxVectorGlobalDiagonal = size.length();
-        const frustumSlope = this._getFrustumSlope();
-        // Formula for setting distance
-        // (Good explanation: http://stackoverflow.com/questions/2866350/move-camera-to-fit-3d-scene)
-        const radiusWithoutFraming = boxVectorGlobalDiagonal * 0.5;
-        // Horizon distance
-        const radius = radiusWithoutFraming * this._radiusScale;
-        const distanceForHorizontalFrustum = radius * Math.sqrt(1.0 + 1.0 / (frustumSlope.x * frustumSlope.x));
-        const distanceForVerticalFrustum = radius * Math.sqrt(1.0 + 1.0 / (frustumSlope.y * frustumSlope.y));
-        let distance = Math.max(distanceForHorizontalFrustum, distanceForVerticalFrustum);
-        const camera = this._attachedCamera;
-        if (!camera) {
-            return 0;
-        }
-        if (camera.lowerRadiusLimit && this._mode === FramingBehavior.IgnoreBoundsSizeMode) {
-            // Don't exceed the requested limit
-            distance = distance < camera.lowerRadiusLimit ? camera.lowerRadiusLimit : distance;
-        }
-        // Don't exceed the upper radius limit
-        if (camera.upperRadiusLimit) {
-            distance = distance > camera.upperRadiusLimit ? camera.upperRadiusLimit : distance;
-        }
-        return distance;
-    }
-    /**
-     * Keeps the camera above the ground plane. If the user pulls the camera below the ground plane, the camera
-     * is automatically returned to its default position (expected to be above ground plane).
-     */
-    _maintainCameraAboveGround() {
-        if (this._elevationReturnTime < 0) {
-            return;
-        }
-        const timeSinceInteraction = PrecisionDate.Now - this._lastInteractionTime;
-        const defaultBeta = Math.PI * 0.5 - this._defaultElevation;
-        const limitBeta = Math.PI * 0.5;
-        // Bring the camera back up if below the ground plane
-        if (this._attachedCamera && !this._betaIsAnimating && this._attachedCamera.beta > limitBeta && timeSinceInteraction >= this._elevationReturnWaitTime) {
-            this._betaIsAnimating = true;
-            //Transition to new position
-            this.stopAllAnimations();
-            if (!this._betaTransition) {
-                this._betaTransition = Animation.CreateAnimation("beta", Animation.ANIMATIONTYPE_FLOAT, 60, FramingBehavior.EasingFunction);
-            }
-            const animatabe = Animation.TransitionTo("beta", defaultBeta, this._attachedCamera, this._attachedCamera.getScene(), 60, this._betaTransition, this._elevationReturnTime, () => {
-                this._clearAnimationLocks();
-                this.stopAllAnimations();
-            });
-            if (animatabe) {
-                this._animatables.push(animatabe);
-            }
-        }
-    }
-    /**
-     * Returns the frustum slope based on the canvas ratio and camera FOV
-     * @returns The frustum slope represented as a Vector2 with X and Y slopes
-     */
-    _getFrustumSlope() {
-        // Calculate the viewport ratio
-        // Aspect Ratio is Height/Width.
-        const camera = this._attachedCamera;
-        if (!camera) {
-            return Vector2.Zero();
-        }
-        const engine = camera.getScene().getEngine();
-        const aspectRatio = engine.getAspectRatio(camera);
-        // Camera FOV is the vertical field of view (top-bottom) in radians.
-        // Slope of the frustum top/bottom planes in view space, relative to the forward vector.
-        const frustumSlopeY = Math.tan(camera.fov / 2);
-        // Slope of the frustum left/right planes in view space, relative to the forward vector.
-        // Provides the amount that one side (e.g. left) of the frustum gets wider for every unit
-        // along the forward vector.
-        const frustumSlopeX = frustumSlopeY * aspectRatio;
-        return new Vector2(frustumSlopeX, frustumSlopeY);
-    }
-    /**
-     * Removes all animation locks. Allows new animations to be added to any of the arcCamera properties.
-     */
-    _clearAnimationLocks() {
-        this._betaIsAnimating = false;
-    }
-    /**
-     *  Applies any current user interaction to the camera. Takes into account maximum alpha rotation.
-     */
-    _applyUserInteraction() {
-        if (this.isUserIsMoving) {
-            this._lastInteractionTime = PrecisionDate.Now;
-            this.stopAllAnimations();
-            this._clearAnimationLocks();
-        }
-    }
-    /**
-     * Stops and removes all animations that have been applied to the camera
-     */
-    stopAllAnimations() {
-        if (this._attachedCamera) {
-            this._attachedCamera.animations = [];
-        }
-        while (this._animatables.length) {
-            if (this._animatables[0]) {
-                this._animatables[0].onAnimationEnd = null;
-                this._animatables[0].stop();
-            }
-            this._animatables.shift();
-        }
-    }
-    /**
-     * Gets a value indicating if the user is moving the camera
-     */
-    get isUserIsMoving() {
-        if (!this._attachedCamera) {
-            return false;
-        }
-        return (this._attachedCamera.inertialAlphaOffset !== 0 ||
-            this._attachedCamera.inertialBetaOffset !== 0 ||
-            this._attachedCamera.inertialRadiusOffset !== 0 ||
-            this._attachedCamera.inertialPanningX !== 0 ||
-            this._attachedCamera.inertialPanningY !== 0 ||
-            this._isPointerDown);
-    }
-}
-/**
- * The easing function used by animations
- */
-FramingBehavior.EasingFunction = new ExponentialEase();
-/**
- * The easing mode used by animations
- */
-FramingBehavior.EasingMode = EasingFunction.EASINGMODE_EASEINOUT;
-// Statics
-/**
- * The camera can move all the way towards the mesh.
- */
-FramingBehavior.IgnoreBoundsSizeMode = 0;
-/**
- * The camera is not allowed to zoom closer to the mesh than the point at which the adjusted bounding sphere touches the frustum sides
- */
-FramingBehavior.FitFrustumSidesMode = 1;
-
-/**
- * A target camera takes a mesh or position as a target and continues to look at it while it moves.
- * This is the base of the follow, arc rotate cameras and Free camera
- * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras
- */
-class TargetCamera extends Camera {
-    /**
-     * Instantiates a target camera that takes a mesh or position as a target and continues to look at it while it moves.
-     * This is the base of the follow, arc rotate cameras and Free camera
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras
-     * @param name Defines the name of the camera in the scene
-     * @param position Defines the start position of the camera in the scene
-     * @param scene Defines the scene the camera belongs to
-     * @param setActiveOnSceneIfNoneActive Defines whether the camera should be marked as active if not other active cameras have been defined
-     */
-    constructor(name, position, scene, setActiveOnSceneIfNoneActive = true) {
-        super(name, position, scene, setActiveOnSceneIfNoneActive);
-        this._tmpUpVector = Vector3.Zero();
-        this._tmpTargetVector = Vector3.Zero();
-        /**
-         * Define the current direction the camera is moving to
-         */
-        this.cameraDirection = new Vector3(0, 0, 0);
-        /**
-         * Define the current rotation the camera is rotating to
-         */
-        this.cameraRotation = new Vector2(0, 0);
-        /** Gets or sets a boolean indicating that the scaling of the parent hierarchy will not be taken in account by the camera */
-        this.ignoreParentScaling = false;
-        /**
-         * When set, the up vector of the camera will be updated by the rotation of the camera
-         */
-        this.updateUpVectorFromRotation = false;
-        this._tmpQuaternion = new Quaternion();
-        /**
-         * Define the current rotation of the camera
-         */
-        this.rotation = new Vector3(0, 0, 0);
-        /**
-         * Define the current speed of the camera
-         */
-        this.speed = 2.0;
-        /**
-         * Add constraint to the camera to prevent it to move freely in all directions and
-         * around all axis.
-         */
-        this.noRotationConstraint = false;
-        /**
-         * Reverses mouselook direction to 'natural' panning as opposed to traditional direct
-         * panning
-         */
-        this.invertRotation = false;
-        /**
-         * Speed multiplier for inverse camera panning
-         */
-        this.inverseRotationSpeed = 0.2;
-        /**
-         * Define the current target of the camera as an object or a position.
-         * Please note that locking a target will disable panning.
-         */
-        this.lockedTarget = null;
-        /** @internal */
-        this._currentTarget = Vector3.Zero();
-        /** @internal */
-        this._initialFocalDistance = 1;
-        /** @internal */
-        this._viewMatrix = Matrix.Zero();
-        /** @internal */
-        this._camMatrix = Matrix.Zero();
-        /** @internal */
-        this._cameraTransformMatrix = Matrix.Zero();
-        /** @internal */
-        this._cameraRotationMatrix = Matrix.Zero();
-        /** @internal */
-        this._referencePoint = new Vector3(0, 0, 1);
-        /** @internal */
-        this._transformedReferencePoint = Vector3.Zero();
-        this._deferredPositionUpdate = new Vector3();
-        this._deferredRotationQuaternionUpdate = new Quaternion();
-        this._deferredRotationUpdate = new Vector3();
-        this._deferredUpdated = false;
-        this._deferOnly = false;
-        this._defaultUp = Vector3.Up();
-        this._cachedRotationZ = 0;
-        this._cachedQuaternionRotationZ = 0;
-    }
-    /**
-     * Gets the position in front of the camera at a given distance.
-     * @param distance The distance from the camera we want the position to be
-     * @returns the position
-     */
-    getFrontPosition(distance) {
-        this.getWorldMatrix();
-        const direction = this.getTarget().subtract(this.position);
-        direction.normalize();
-        direction.scaleInPlace(distance);
-        return this.globalPosition.add(direction);
-    }
-    /** @internal */
-    _getLockedTargetPosition() {
-        if (!this.lockedTarget) {
-            return null;
-        }
-        if (this.lockedTarget.absolutePosition) {
-            const lockedTarget = this.lockedTarget;
-            const m = lockedTarget.computeWorldMatrix();
-            // in some cases the absolute position resets externally, but doesn't update since the matrix is cached.
-            m.getTranslationToRef(lockedTarget.absolutePosition);
-        }
-        return this.lockedTarget.absolutePosition || this.lockedTarget;
-    }
-    /**
-     * Store current camera state of the camera (fov, position, rotation, etc..)
-     * @returns the camera
-     */
-    storeState() {
-        this._storedPosition = this.position.clone();
-        this._storedRotation = this.rotation.clone();
-        if (this.rotationQuaternion) {
-            this._storedRotationQuaternion = this.rotationQuaternion.clone();
-        }
-        return super.storeState();
-    }
-    /**
-     * Restored camera state. You must call storeState() first
-     * @returns whether it was successful or not
-     * @internal
-     */
-    _restoreStateValues() {
-        if (!super._restoreStateValues()) {
-            return false;
-        }
-        this.position = this._storedPosition.clone();
-        this.rotation = this._storedRotation.clone();
-        if (this.rotationQuaternion) {
-            this.rotationQuaternion = this._storedRotationQuaternion.clone();
-        }
-        this.cameraDirection.copyFromFloats(0, 0, 0);
-        this.cameraRotation.copyFromFloats(0, 0);
-        return true;
-    }
-    /** @internal */
-    _initCache() {
-        super._initCache();
-        this._cache.lockedTarget = new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-        this._cache.rotation = new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-        this._cache.rotationQuaternion = new Quaternion(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-    }
-    /**
-     * @internal
-     */
-    _updateCache(ignoreParentClass) {
-        if (!ignoreParentClass) {
-            super._updateCache();
-        }
-        const lockedTargetPosition = this._getLockedTargetPosition();
-        if (!lockedTargetPosition) {
-            this._cache.lockedTarget = null;
-        }
-        else {
-            if (!this._cache.lockedTarget) {
-                this._cache.lockedTarget = lockedTargetPosition.clone();
-            }
-            else {
-                this._cache.lockedTarget.copyFrom(lockedTargetPosition);
-            }
-        }
-        this._cache.rotation.copyFrom(this.rotation);
-        if (this.rotationQuaternion) {
-            this._cache.rotationQuaternion.copyFrom(this.rotationQuaternion);
-        }
-    }
-    // Synchronized
-    /** @internal */
-    _isSynchronizedViewMatrix() {
-        if (!super._isSynchronizedViewMatrix()) {
-            return false;
-        }
-        const lockedTargetPosition = this._getLockedTargetPosition();
-        return ((this._cache.lockedTarget ? this._cache.lockedTarget.equals(lockedTargetPosition) : !lockedTargetPosition) &&
-            (this.rotationQuaternion ? this.rotationQuaternion.equals(this._cache.rotationQuaternion) : this._cache.rotation.equals(this.rotation)));
-    }
-    // Methods
-    /** @internal */
-    _computeLocalCameraSpeed() {
-        const engine = this.getEngine();
-        return this.speed * Math.sqrt(engine.getDeltaTime() / (engine.getFps() * 100.0));
-    }
-    // Target
-    /**
-     * Defines the target the camera should look at.
-     * @param target Defines the new target as a Vector
-     */
-    setTarget(target) {
-        this.upVector.normalize();
-        this._initialFocalDistance = target.subtract(this.position).length();
-        if (this.position.z === target.z) {
-            this.position.z += Epsilon;
-        }
-        this._referencePoint.normalize().scaleInPlace(this._initialFocalDistance);
-        Matrix.LookAtLHToRef(this.position, target, this._defaultUp, this._camMatrix);
-        this._camMatrix.invert();
-        this.rotation.x = Math.atan(this._camMatrix.m[6] / this._camMatrix.m[10]);
-        const vDir = target.subtract(this.position);
-        if (vDir.x >= 0.0) {
-            this.rotation.y = -Math.atan(vDir.z / vDir.x) + Math.PI / 2.0;
-        }
-        else {
-            this.rotation.y = -Math.atan(vDir.z / vDir.x) - Math.PI / 2.0;
-        }
-        this.rotation.z = 0;
-        if (isNaN(this.rotation.x)) {
-            this.rotation.x = 0;
-        }
-        if (isNaN(this.rotation.y)) {
-            this.rotation.y = 0;
-        }
-        if (isNaN(this.rotation.z)) {
-            this.rotation.z = 0;
-        }
-        if (this.rotationQuaternion) {
-            Quaternion.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, this.rotation.z, this.rotationQuaternion);
-        }
-    }
-    /**
-     * Defines the target point of the camera.
-     * The camera looks towards it form the radius distance.
-     */
-    get target() {
-        return this.getTarget();
-    }
-    set target(value) {
-        this.setTarget(value);
-    }
-    /**
-     * Return the current target position of the camera. This value is expressed in local space.
-     * @returns the target position
-     */
-    getTarget() {
-        return this._currentTarget;
-    }
-    /** @internal */
-    _decideIfNeedsToMove() {
-        return Math.abs(this.cameraDirection.x) > 0 || Math.abs(this.cameraDirection.y) > 0 || Math.abs(this.cameraDirection.z) > 0;
-    }
-    /** @internal */
-    _updatePosition() {
-        if (this.parent) {
-            this.parent.getWorldMatrix().invertToRef(TmpVectors.Matrix[0]);
-            Vector3.TransformNormalToRef(this.cameraDirection, TmpVectors.Matrix[0], TmpVectors.Vector3[0]);
-            this._deferredPositionUpdate.addInPlace(TmpVectors.Vector3[0]);
-            if (!this._deferOnly) {
-                this.position.copyFrom(this._deferredPositionUpdate);
-            }
-            else {
-                this._deferredUpdated = true;
-            }
-            return;
-        }
-        this._deferredPositionUpdate.addInPlace(this.cameraDirection);
-        if (!this._deferOnly) {
-            this.position.copyFrom(this._deferredPositionUpdate);
-        }
-        else {
-            this._deferredUpdated = true;
-        }
-    }
-    /** @internal */
-    _checkInputs() {
-        const directionMultiplier = this.invertRotation ? -this.inverseRotationSpeed : 1.0;
-        const needToMove = this._decideIfNeedsToMove();
-        const needToRotate = this.cameraRotation.x || this.cameraRotation.y;
-        this._deferredUpdated = false;
-        this._deferredRotationUpdate.copyFrom(this.rotation);
-        this._deferredPositionUpdate.copyFrom(this.position);
-        if (this.rotationQuaternion) {
-            this._deferredRotationQuaternionUpdate.copyFrom(this.rotationQuaternion);
-        }
-        // Move
-        if (needToMove) {
-            this._updatePosition();
-        }
-        // Rotate
-        if (needToRotate) {
-            //rotate, if quaternion is set and rotation was used
-            if (this.rotationQuaternion) {
-                this.rotationQuaternion.toEulerAnglesToRef(this._deferredRotationUpdate);
-            }
-            this._deferredRotationUpdate.x += this.cameraRotation.x * directionMultiplier;
-            this._deferredRotationUpdate.y += this.cameraRotation.y * directionMultiplier;
-            // Apply constraints
-            if (!this.noRotationConstraint) {
-                const limit = 1.570796;
-                if (this._deferredRotationUpdate.x > limit) {
-                    this._deferredRotationUpdate.x = limit;
-                }
-                if (this._deferredRotationUpdate.x < -limit) {
-                    this._deferredRotationUpdate.x = -limit;
-                }
-            }
-            if (!this._deferOnly) {
-                this.rotation.copyFrom(this._deferredRotationUpdate);
-            }
-            else {
-                this._deferredUpdated = true;
-            }
-            //rotate, if quaternion is set and rotation was used
-            if (this.rotationQuaternion) {
-                const len = this._deferredRotationUpdate.lengthSquared();
-                if (len) {
-                    Quaternion.RotationYawPitchRollToRef(this._deferredRotationUpdate.y, this._deferredRotationUpdate.x, this._deferredRotationUpdate.z, this._deferredRotationQuaternionUpdate);
-                    if (!this._deferOnly) {
-                        this.rotationQuaternion.copyFrom(this._deferredRotationQuaternionUpdate);
-                    }
-                    else {
-                        this._deferredUpdated = true;
-                    }
-                }
-            }
-        }
-        // Inertia
-        if (needToMove) {
-            if (Math.abs(this.cameraDirection.x) < this.speed * Epsilon) {
-                this.cameraDirection.x = 0;
-            }
-            if (Math.abs(this.cameraDirection.y) < this.speed * Epsilon) {
-                this.cameraDirection.y = 0;
-            }
-            if (Math.abs(this.cameraDirection.z) < this.speed * Epsilon) {
-                this.cameraDirection.z = 0;
-            }
-            this.cameraDirection.scaleInPlace(this.inertia);
-        }
-        if (needToRotate) {
-            if (Math.abs(this.cameraRotation.x) < this.speed * Epsilon) {
-                this.cameraRotation.x = 0;
-            }
-            if (Math.abs(this.cameraRotation.y) < this.speed * Epsilon) {
-                this.cameraRotation.y = 0;
-            }
-            this.cameraRotation.scaleInPlace(this.inertia);
-        }
-        super._checkInputs();
-    }
-    _updateCameraRotationMatrix() {
-        if (this.rotationQuaternion) {
-            this.rotationQuaternion.toRotationMatrix(this._cameraRotationMatrix);
-        }
-        else {
-            Matrix.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, this.rotation.z, this._cameraRotationMatrix);
-        }
-    }
-    /**
-     * Update the up vector to apply the rotation of the camera (So if you changed the camera rotation.z this will let you update the up vector as well)
-     * @returns the current camera
-     */
-    _rotateUpVectorWithCameraRotationMatrix() {
-        Vector3.TransformNormalToRef(this._defaultUp, this._cameraRotationMatrix, this.upVector);
-        return this;
-    }
-    /** @internal */
-    _getViewMatrix() {
-        if (this.lockedTarget) {
-            this.setTarget(this._getLockedTargetPosition());
-        }
-        // Compute
-        this._updateCameraRotationMatrix();
-        // Apply the changed rotation to the upVector
-        if (this.rotationQuaternion && this._cachedQuaternionRotationZ != this.rotationQuaternion.z) {
-            this._rotateUpVectorWithCameraRotationMatrix();
-            this._cachedQuaternionRotationZ = this.rotationQuaternion.z;
-        }
-        else if (this._cachedRotationZ !== this.rotation.z) {
-            this._rotateUpVectorWithCameraRotationMatrix();
-            this._cachedRotationZ = this.rotation.z;
-        }
-        Vector3.TransformCoordinatesToRef(this._referencePoint, this._cameraRotationMatrix, this._transformedReferencePoint);
-        // Computing target and final matrix
-        this.position.addToRef(this._transformedReferencePoint, this._currentTarget);
-        if (this.updateUpVectorFromRotation) {
-            if (this.rotationQuaternion) {
-                Axis.Y.rotateByQuaternionToRef(this.rotationQuaternion, this.upVector);
-            }
-            else {
-                Quaternion.FromEulerVectorToRef(this.rotation, this._tmpQuaternion);
-                Axis.Y.rotateByQuaternionToRef(this._tmpQuaternion, this.upVector);
-            }
-        }
-        this._computeViewMatrix(this.position, this._currentTarget, this.upVector);
-        return this._viewMatrix;
-    }
-    _computeViewMatrix(position, target, up) {
-        if (this.ignoreParentScaling) {
-            if (this.parent) {
-                const parentWorldMatrix = this.parent.getWorldMatrix();
-                Vector3.TransformCoordinatesToRef(position, parentWorldMatrix, this._globalPosition);
-                Vector3.TransformCoordinatesToRef(target, parentWorldMatrix, this._tmpTargetVector);
-                Vector3.TransformNormalToRef(up, parentWorldMatrix, this._tmpUpVector);
-                this._markSyncedWithParent();
-            }
-            else {
-                this._globalPosition.copyFrom(position);
-                this._tmpTargetVector.copyFrom(target);
-                this._tmpUpVector.copyFrom(up);
-            }
-            if (this.getScene().useRightHandedSystem) {
-                Matrix.LookAtRHToRef(this._globalPosition, this._tmpTargetVector, this._tmpUpVector, this._viewMatrix);
-            }
-            else {
-                Matrix.LookAtLHToRef(this._globalPosition, this._tmpTargetVector, this._tmpUpVector, this._viewMatrix);
-            }
-            return;
-        }
-        if (this.getScene().useRightHandedSystem) {
-            Matrix.LookAtRHToRef(position, target, up, this._viewMatrix);
-        }
-        else {
-            Matrix.LookAtLHToRef(position, target, up, this._viewMatrix);
-        }
-        if (this.parent) {
-            const parentWorldMatrix = this.parent.getWorldMatrix();
-            this._viewMatrix.invert();
-            this._viewMatrix.multiplyToRef(parentWorldMatrix, this._viewMatrix);
-            this._viewMatrix.getTranslationToRef(this._globalPosition);
-            this._viewMatrix.invert();
-            this._markSyncedWithParent();
-        }
-        else {
-            this._globalPosition.copyFrom(position);
-        }
-    }
-    /**
-     * @internal
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    createRigCamera(name, cameraIndex) {
-        if (this.cameraRigMode !== Camera.RIG_MODE_NONE) {
-            const rigCamera = new TargetCamera(name, this.position.clone(), this.getScene());
-            rigCamera.isRigCamera = true;
-            rigCamera.rigParent = this;
-            if (this.cameraRigMode === Camera.RIG_MODE_VR || this.cameraRigMode === Camera.RIG_MODE_WEBVR) {
-                if (!this.rotationQuaternion) {
-                    this.rotationQuaternion = new Quaternion();
-                }
-                rigCamera._cameraRigParams = {};
-                rigCamera.rotationQuaternion = new Quaternion();
-            }
-            rigCamera.mode = this.mode;
-            rigCamera.orthoLeft = this.orthoLeft;
-            rigCamera.orthoRight = this.orthoRight;
-            rigCamera.orthoTop = this.orthoTop;
-            rigCamera.orthoBottom = this.orthoBottom;
-            return rigCamera;
-        }
-        return null;
-    }
-    /**
-     * @internal
-     */
-    _updateRigCameras() {
-        const camLeft = this._rigCameras[0];
-        const camRight = this._rigCameras[1];
-        this.computeWorldMatrix();
-        switch (this.cameraRigMode) {
-            case Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH:
-            case Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL:
-            case Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_CROSSEYED:
-            case Camera.RIG_MODE_STEREOSCOPIC_OVERUNDER:
-            case Camera.RIG_MODE_STEREOSCOPIC_INTERLACED: {
-                //provisionnaly using _cameraRigParams.stereoHalfAngle instead of calculations based on _cameraRigParams.interaxialDistance:
-                const leftSign = this.cameraRigMode === Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_CROSSEYED ? 1 : -1;
-                const rightSign = this.cameraRigMode === Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_CROSSEYED ? -1 : 1;
-                this._getRigCamPositionAndTarget(this._cameraRigParams.stereoHalfAngle * leftSign, camLeft);
-                this._getRigCamPositionAndTarget(this._cameraRigParams.stereoHalfAngle * rightSign, camRight);
-                break;
-            }
-            case Camera.RIG_MODE_VR:
-                if (camLeft.rotationQuaternion) {
-                    camLeft.rotationQuaternion.copyFrom(this.rotationQuaternion);
-                    camRight.rotationQuaternion.copyFrom(this.rotationQuaternion);
-                }
-                else {
-                    camLeft.rotation.copyFrom(this.rotation);
-                    camRight.rotation.copyFrom(this.rotation);
-                }
-                camLeft.position.copyFrom(this.position);
-                camRight.position.copyFrom(this.position);
-                break;
-        }
-        super._updateRigCameras();
-    }
-    _getRigCamPositionAndTarget(halfSpace, rigCamera) {
-        const target = this.getTarget();
-        target.subtractToRef(this.position, TargetCamera._TargetFocalPoint);
-        TargetCamera._TargetFocalPoint.normalize().scaleInPlace(this._initialFocalDistance);
-        const newFocalTarget = TargetCamera._TargetFocalPoint.addInPlace(this.position);
-        Matrix.TranslationToRef(-newFocalTarget.x, -newFocalTarget.y, -newFocalTarget.z, TargetCamera._TargetTransformMatrix);
-        TargetCamera._TargetTransformMatrix.multiplyToRef(Matrix.RotationAxis(rigCamera.upVector, halfSpace), TargetCamera._RigCamTransformMatrix);
-        Matrix.TranslationToRef(newFocalTarget.x, newFocalTarget.y, newFocalTarget.z, TargetCamera._TargetTransformMatrix);
-        TargetCamera._RigCamTransformMatrix.multiplyToRef(TargetCamera._TargetTransformMatrix, TargetCamera._RigCamTransformMatrix);
-        Vector3.TransformCoordinatesToRef(this.position, TargetCamera._RigCamTransformMatrix, rigCamera.position);
-        rigCamera.setTarget(newFocalTarget);
-    }
-    /**
-     * Gets the current object class name.
-     * @returns the class name
-     */
-    getClassName() {
-        return "TargetCamera";
-    }
-}
-TargetCamera._RigCamTransformMatrix = new Matrix();
-TargetCamera._TargetTransformMatrix = new Matrix();
-TargetCamera._TargetFocalPoint = new Vector3();
-__decorate([
-    serializeAsVector3()
-], TargetCamera.prototype, "rotation", void 0);
-__decorate([
-    serialize()
-], TargetCamera.prototype, "speed", void 0);
-__decorate([
-    serializeAsMeshReference("lockedTargetId")
-], TargetCamera.prototype, "lockedTarget", void 0);
-
-/**
- * @ignore
- * This is a list of all the different input types that are available in the application.
- * Fo instance: ArcRotateCameraGamepadInput...
- */
-// eslint-disable-next-line no-var, @typescript-eslint/naming-convention
-var CameraInputTypes = {};
-/**
- * This represents the input manager used within a camera.
- * It helps dealing with all the different kind of input attached to a camera.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/customizingCameraInputs
- */
-class CameraInputsManager {
-    /**
-     * Instantiate a new Camera Input Manager.
-     * @param camera Defines the camera the input manager belongs to
-     */
-    constructor(camera) {
-        /**
-         * Defines the dom element the camera is collecting inputs from.
-         * This is null if the controls have not been attached.
-         */
-        this.attachedToElement = false;
-        this.attached = {};
-        this.camera = camera;
-        this.checkInputs = () => { };
-    }
-    /**
-     * Add an input method to a camera
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/customizingCameraInputs
-     * @param input Camera input method
-     */
-    add(input) {
-        const type = input.getSimpleName();
-        if (this.attached[type]) {
-            Logger.Warn("camera input of type " + type + " already exists on camera");
-            return;
-        }
-        this.attached[type] = input;
-        input.camera = this.camera;
-        // for checkInputs, we are dynamically creating a function
-        // the goal is to avoid the performance penalty of looping for inputs in the render loop
-        if (input.checkInputs) {
-            this.checkInputs = this._addCheckInputs(input.checkInputs.bind(input));
-        }
-        if (this.attachedToElement) {
-            input.attachControl(this.noPreventDefault);
-        }
-    }
-    /**
-     * Remove a specific input method from a camera
-     * example: camera.inputs.remove(camera.inputs.attached.mouse);
-     * @param inputToRemove camera input method
-     */
-    remove(inputToRemove) {
-        for (const cam in this.attached) {
-            const input = this.attached[cam];
-            if (input === inputToRemove) {
-                input.detachControl();
-                input.camera = null;
-                delete this.attached[cam];
-                this.rebuildInputCheck();
-                return;
-            }
-        }
-    }
-    /**
-     * Remove a specific input type from a camera
-     * example: camera.inputs.remove("ArcRotateCameraGamepadInput");
-     * @param inputType the type of the input to remove
-     */
-    removeByType(inputType) {
-        for (const cam in this.attached) {
-            const input = this.attached[cam];
-            if (input.getClassName() === inputType) {
-                input.detachControl();
-                input.camera = null;
-                delete this.attached[cam];
-                this.rebuildInputCheck();
-            }
-        }
-    }
-    _addCheckInputs(fn) {
-        const current = this.checkInputs;
-        return () => {
-            current();
-            fn();
-        };
-    }
-    /**
-     * Attach the input controls to the currently attached dom element to listen the events from.
-     * @param input Defines the input to attach
-     */
-    attachInput(input) {
-        if (this.attachedToElement) {
-            input.attachControl(this.noPreventDefault);
-        }
-    }
-    /**
-     * Attach the current manager inputs controls to a specific dom element to listen the events from.
-     * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
-     */
-    attachElement(noPreventDefault = false) {
-        if (this.attachedToElement) {
-            return;
-        }
-        noPreventDefault = Camera.ForceAttachControlToAlwaysPreventDefault ? false : noPreventDefault;
-        this.attachedToElement = true;
-        this.noPreventDefault = noPreventDefault;
-        for (const cam in this.attached) {
-            this.attached[cam].attachControl(noPreventDefault);
-        }
-    }
-    /**
-     * Detach the current manager inputs controls from a specific dom element.
-     * @param disconnect Defines whether the input should be removed from the current list of attached inputs
-     */
-    detachElement(disconnect = false) {
-        for (const cam in this.attached) {
-            this.attached[cam].detachControl();
-            if (disconnect) {
-                this.attached[cam].camera = null;
-            }
-        }
-        this.attachedToElement = false;
-    }
-    /**
-     * Rebuild the dynamic inputCheck function from the current list of
-     * defined inputs in the manager.
-     */
-    rebuildInputCheck() {
-        this.checkInputs = () => { };
-        for (const cam in this.attached) {
-            const input = this.attached[cam];
-            if (input.checkInputs) {
-                this.checkInputs = this._addCheckInputs(input.checkInputs.bind(input));
-            }
-        }
-    }
-    /**
-     * Remove all attached input methods from a camera
-     */
-    clear() {
-        if (this.attachedToElement) {
-            this.detachElement(true);
-        }
-        this.attached = {};
-        this.attachedToElement = false;
-        this.checkInputs = () => { };
-    }
-    /**
-     * Serialize the current input manager attached to a camera.
-     * This ensures than once parsed,
-     * the input associated to the camera will be identical to the current ones
-     * @param serializedCamera Defines the camera serialization JSON the input serialization should write to
-     */
-    serialize(serializedCamera) {
-        const inputs = {};
-        for (const cam in this.attached) {
-            const input = this.attached[cam];
-            const res = SerializationHelper.Serialize(input);
-            inputs[input.getClassName()] = res;
-        }
-        serializedCamera.inputsmgr = inputs;
-    }
-    /**
-     * Parses an input manager serialized JSON to restore the previous list of inputs
-     * and states associated to a camera.
-     * @param parsedCamera Defines the JSON to parse
-     */
-    parse(parsedCamera) {
-        const parsedInputs = parsedCamera.inputsmgr;
-        if (parsedInputs) {
-            this.clear();
-            for (const n in parsedInputs) {
-                const construct = CameraInputTypes[n];
-                if (construct) {
-                    const parsedinput = parsedInputs[n];
-                    const input = SerializationHelper.Parse(() => {
-                        return new construct();
-                    }, parsedinput, null);
-                    this.add(input);
-                }
-            }
-        }
-        else {
-            //2016-03-08 this part is for managing backward compatibility
-            for (const n in this.attached) {
-                const construct = CameraInputTypes[this.attached[n].getClassName()];
-                if (construct) {
-                    const input = SerializationHelper.Parse(() => {
-                        return new construct();
-                    }, parsedCamera, null);
-                    this.remove(this.attached[n]);
-                    this.add(input);
-                }
-            }
-        }
-    }
-}
-
-/**
- * Base class for Camera Pointer Inputs.
- * See FollowCameraPointersInput in src/Cameras/Inputs/followCameraPointersInput.ts
- * for example usage.
- */
-class BaseCameraPointersInput {
-    constructor() {
-        this._currentActiveButton = -1;
-        /**
-         * Defines the buttons associated with the input to handle camera move.
-         */
-        this.buttons = [0, 1, 2];
-    }
-    /**
-     * Attach the input controls to a specific dom element to get the input from.
-     * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
-     */
-    attachControl(noPreventDefault) {
-        // eslint-disable-next-line prefer-rest-params
-        noPreventDefault = Tools.BackCompatCameraNoPreventDefault(arguments);
-        const engine = this.camera.getEngine();
-        const element = engine.getInputElement();
-        let previousPinchSquaredDistance = 0;
-        let previousMultiTouchPanPosition = null;
-        this._pointA = null;
-        this._pointB = null;
-        this._altKey = false;
-        this._ctrlKey = false;
-        this._metaKey = false;
-        this._shiftKey = false;
-        this._buttonsPressed = 0;
-        this._pointerInput = (p) => {
-            var _a, _b;
-            const evt = p.event;
-            const isTouch = evt.pointerType === "touch";
-            if (engine.isInVRExclusivePointerMode) {
-                return;
-            }
-            if (p.type !== PointerEventTypes.POINTERMOVE && this.buttons.indexOf(evt.button) === -1) {
-                return;
-            }
-            const srcElement = evt.target;
-            this._altKey = evt.altKey;
-            this._ctrlKey = evt.ctrlKey;
-            this._metaKey = evt.metaKey;
-            this._shiftKey = evt.shiftKey;
-            this._buttonsPressed = evt.buttons;
-            if (engine.isPointerLock) {
-                const offsetX = evt.movementX;
-                const offsetY = evt.movementY;
-                this.onTouch(null, offsetX, offsetY);
-                this._pointA = null;
-                this._pointB = null;
-            }
-            else if (p.type !== PointerEventTypes.POINTERDOWN && isTouch && ((_a = this._pointA) === null || _a === void 0 ? void 0 : _a.pointerId) !== evt.pointerId && ((_b = this._pointB) === null || _b === void 0 ? void 0 : _b.pointerId) !== evt.pointerId) {
-                return; // If we get a non-down event for a touch that we're not tracking, ignore it
-            }
-            else if (p.type === PointerEventTypes.POINTERDOWN && (this._currentActiveButton === -1 || isTouch)) {
-                try {
-                    srcElement === null || srcElement === void 0 ? void 0 : srcElement.setPointerCapture(evt.pointerId);
-                }
-                catch (e) {
-                    //Nothing to do with the error. Execution will continue.
-                }
-                if (this._pointA === null) {
-                    this._pointA = {
-                        x: evt.clientX,
-                        y: evt.clientY,
-                        pointerId: evt.pointerId,
-                        type: evt.pointerType,
-                    };
-                }
-                else if (this._pointB === null) {
-                    this._pointB = {
-                        x: evt.clientX,
-                        y: evt.clientY,
-                        pointerId: evt.pointerId,
-                        type: evt.pointerType,
-                    };
-                }
-                else {
-                    return; // We are already tracking two pointers so ignore this one
-                }
-                if (this._currentActiveButton === -1 && !isTouch) {
-                    this._currentActiveButton = evt.button;
-                }
-                this.onButtonDown(evt);
-                if (!noPreventDefault) {
-                    evt.preventDefault();
-                    element && element.focus();
-                }
-            }
-            else if (p.type === PointerEventTypes.POINTERDOUBLETAP) {
-                this.onDoubleTap(evt.pointerType);
-            }
-            else if (p.type === PointerEventTypes.POINTERUP && (this._currentActiveButton === evt.button || isTouch)) {
-                try {
-                    srcElement === null || srcElement === void 0 ? void 0 : srcElement.releasePointerCapture(evt.pointerId);
-                }
-                catch (e) {
-                    //Nothing to do with the error.
-                }
-                if (!isTouch) {
-                    this._pointB = null; // Mouse and pen are mono pointer
-                }
-                //would be better to use pointers.remove(evt.pointerId) for multitouch gestures,
-                //but emptying completely pointers collection is required to fix a bug on iPhone :
-                //when changing orientation while pinching camera,
-                //one pointer stay pressed forever if we don't release all pointers
-                //will be ok to put back pointers.remove(evt.pointerId); when iPhone bug corrected
-                if (engine._badOS) {
-                    this._pointA = this._pointB = null;
-                }
-                else {
-                    //only remove the impacted pointer in case of multitouch allowing on most
-                    //platforms switching from rotate to zoom and pan seamlessly.
-                    if (this._pointB && this._pointA && this._pointA.pointerId == evt.pointerId) {
-                        this._pointA = this._pointB;
-                        this._pointB = null;
-                    }
-                    else if (this._pointA && this._pointB && this._pointB.pointerId == evt.pointerId) {
-                        this._pointB = null;
-                    }
-                    else {
-                        this._pointA = this._pointB = null;
-                    }
-                }
-                if (previousPinchSquaredDistance !== 0 || previousMultiTouchPanPosition) {
-                    // Previous pinch data is populated but a button has been lifted
-                    // so pinch has ended.
-                    this.onMultiTouch(this._pointA, this._pointB, previousPinchSquaredDistance, 0, // pinchSquaredDistance
-                    previousMultiTouchPanPosition, null // multiTouchPanPosition
-                    );
-                    previousPinchSquaredDistance = 0;
-                    previousMultiTouchPanPosition = null;
-                }
-                this._currentActiveButton = -1;
-                this.onButtonUp(evt);
-                if (!noPreventDefault) {
-                    evt.preventDefault();
-                }
-            }
-            else if (p.type === PointerEventTypes.POINTERMOVE) {
-                if (!noPreventDefault) {
-                    evt.preventDefault();
-                }
-                // One button down
-                if (this._pointA && this._pointB === null) {
-                    const offsetX = evt.clientX - this._pointA.x;
-                    const offsetY = evt.clientY - this._pointA.y;
-                    this.onTouch(this._pointA, offsetX, offsetY);
-                    this._pointA.x = evt.clientX;
-                    this._pointA.y = evt.clientY;
-                }
-                // Two buttons down: pinch
-                else if (this._pointA && this._pointB) {
-                    const ed = this._pointA.pointerId === evt.pointerId ? this._pointA : this._pointB;
-                    ed.x = evt.clientX;
-                    ed.y = evt.clientY;
-                    const distX = this._pointA.x - this._pointB.x;
-                    const distY = this._pointA.y - this._pointB.y;
-                    const pinchSquaredDistance = distX * distX + distY * distY;
-                    const multiTouchPanPosition = {
-                        x: (this._pointA.x + this._pointB.x) / 2,
-                        y: (this._pointA.y + this._pointB.y) / 2,
-                        pointerId: evt.pointerId,
-                        type: p.type,
-                    };
-                    this.onMultiTouch(this._pointA, this._pointB, previousPinchSquaredDistance, pinchSquaredDistance, previousMultiTouchPanPosition, multiTouchPanPosition);
-                    previousMultiTouchPanPosition = multiTouchPanPosition;
-                    previousPinchSquaredDistance = pinchSquaredDistance;
-                }
-            }
-        };
-        this._observer = this.camera
-            .getScene()
-            ._inputManager._addCameraPointerObserver(this._pointerInput, PointerEventTypes.POINTERDOWN | PointerEventTypes.POINTERUP | PointerEventTypes.POINTERMOVE | PointerEventTypes.POINTERDOUBLETAP);
-        this._onLostFocus = () => {
-            this._pointA = this._pointB = null;
-            previousPinchSquaredDistance = 0;
-            previousMultiTouchPanPosition = null;
-            this.onLostFocus();
-        };
-        this._contextMenuBind = this.onContextMenu.bind(this);
-        element && element.addEventListener("contextmenu", this._contextMenuBind, false);
-        const hostWindow = this.camera.getScene().getEngine().getHostWindow();
-        if (hostWindow) {
-            Tools.RegisterTopRootEvents(hostWindow, [{ name: "blur", handler: this._onLostFocus }]);
-        }
-    }
-    /**
-     * Detach the current controls from the specified dom element.
-     */
-    detachControl() {
-        if (this._onLostFocus) {
-            const hostWindow = this.camera.getScene().getEngine().getHostWindow();
-            if (hostWindow) {
-                Tools.UnregisterTopRootEvents(hostWindow, [{ name: "blur", handler: this._onLostFocus }]);
-            }
-        }
-        if (this._observer) {
-            this.camera.getScene()._inputManager._removeCameraPointerObserver(this._observer);
-            this._observer = null;
-            if (this._contextMenuBind) {
-                const inputElement = this.camera.getScene().getEngine().getInputElement();
-                inputElement && inputElement.removeEventListener("contextmenu", this._contextMenuBind);
-            }
-            this._onLostFocus = null;
-        }
-        this._altKey = false;
-        this._ctrlKey = false;
-        this._metaKey = false;
-        this._shiftKey = false;
-        this._buttonsPressed = 0;
-        this._currentActiveButton = -1;
-    }
-    /**
-     * Gets the class name of the current input.
-     * @returns the class name
-     */
-    getClassName() {
-        return "BaseCameraPointersInput";
-    }
-    /**
-     * Get the friendly name associated with the input class.
-     * @returns the input friendly name
-     */
-    getSimpleName() {
-        return "pointers";
-    }
-    /**
-     * Called on pointer POINTERDOUBLETAP event.
-     * Override this method to provide functionality on POINTERDOUBLETAP event.
-     * @param type
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    onDoubleTap(type) { }
-    /**
-     * Called on pointer POINTERMOVE event if only a single touch is active.
-     * Override this method to provide functionality.
-     * @param point
-     * @param offsetX
-     * @param offsetY
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    onTouch(point, offsetX, offsetY) { }
-    /**
-     * Called on pointer POINTERMOVE event if multiple touches are active.
-     * Override this method to provide functionality.
-     * @param _pointA
-     * @param _pointB
-     * @param previousPinchSquaredDistance
-     * @param pinchSquaredDistance
-     * @param previousMultiTouchPanPosition
-     * @param multiTouchPanPosition
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    onMultiTouch(_pointA, _pointB, previousPinchSquaredDistance, pinchSquaredDistance, previousMultiTouchPanPosition, multiTouchPanPosition) { }
-    /**
-     * Called on JS contextmenu event.
-     * Override this method to provide functionality.
-     * @param evt
-     */
-    onContextMenu(evt) {
-        evt.preventDefault();
-    }
-    /**
-     * Called each time a new POINTERDOWN event occurs. Ie, for each button
-     * press.
-     * Override this method to provide functionality.
-     * @param evt
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    onButtonDown(evt) { }
-    /**
-     * Called each time a new POINTERUP event occurs. Ie, for each button
-     * release.
-     * Override this method to provide functionality.
-     * @param evt
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    onButtonUp(evt) { }
-    /**
-     * Called when window becomes inactive.
-     * Override this method to provide functionality.
-     */
-    onLostFocus() { }
-}
-__decorate([
-    serialize()
-], BaseCameraPointersInput.prototype, "buttons", void 0);
-
-/**
- * Manage the pointers inputs to control an arc rotate camera.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/customizingCameraInputs
- */
-class ArcRotateCameraPointersInput extends BaseCameraPointersInput {
-    constructor() {
-        super(...arguments);
-        /**
-         * Defines the buttons associated with the input to handle camera move.
-         */
-        this.buttons = [0, 1, 2];
-        /**
-         * Defines the pointer angular sensibility  along the X axis or how fast is
-         * the camera rotating.
-         */
-        this.angularSensibilityX = 1000.0;
-        /**
-         * Defines the pointer angular sensibility along the Y axis or how fast is
-         * the camera rotating.
-         */
-        this.angularSensibilityY = 1000.0;
-        /**
-         * Defines the pointer pinch precision or how fast is the camera zooming.
-         */
-        this.pinchPrecision = 12.0;
-        /**
-         * pinchDeltaPercentage will be used instead of pinchPrecision if different
-         * from 0.
-         * It defines the percentage of current camera.radius to use as delta when
-         * pinch zoom is used.
-         */
-        this.pinchDeltaPercentage = 0;
-        /**
-         * When useNaturalPinchZoom is true, multi touch zoom will zoom in such
-         * that any object in the plane at the camera's target point will scale
-         * perfectly with finger motion.
-         * Overrides pinchDeltaPercentage and pinchPrecision.
-         */
-        this.useNaturalPinchZoom = false;
-        /**
-         * Defines whether zoom (2 fingers pinch) is enabled through multitouch
-         */
-        this.pinchZoom = true;
-        /**
-         * Defines the pointer panning sensibility or how fast is the camera moving.
-         */
-        this.panningSensibility = 1000.0;
-        /**
-         * Defines whether panning (2 fingers swipe) is enabled through multitouch.
-         */
-        this.multiTouchPanning = true;
-        /**
-         * Defines whether panning is enabled for both pan (2 fingers swipe) and
-         * zoom (pinch) through multitouch.
-         */
-        this.multiTouchPanAndZoom = true;
-        /**
-         * Revers pinch action direction.
-         */
-        this.pinchInwards = true;
-        this._isPanClick = false;
-        this._twoFingerActivityCount = 0;
-        this._isPinching = false;
-    }
-    /**
-     * Gets the class name of the current input.
-     * @returns the class name
-     */
-    getClassName() {
-        return "ArcRotateCameraPointersInput";
-    }
-    /**
-     * Move camera from multi touch panning positions.
-     * @param previousMultiTouchPanPosition
-     * @param multiTouchPanPosition
-     */
-    _computeMultiTouchPanning(previousMultiTouchPanPosition, multiTouchPanPosition) {
-        if (this.panningSensibility !== 0 && previousMultiTouchPanPosition && multiTouchPanPosition) {
-            const moveDeltaX = multiTouchPanPosition.x - previousMultiTouchPanPosition.x;
-            const moveDeltaY = multiTouchPanPosition.y - previousMultiTouchPanPosition.y;
-            this.camera.inertialPanningX += -moveDeltaX / this.panningSensibility;
-            this.camera.inertialPanningY += moveDeltaY / this.panningSensibility;
-        }
-    }
-    /**
-     * Move camera from pinch zoom distances.
-     * @param previousPinchSquaredDistance
-     * @param pinchSquaredDistance
-     */
-    _computePinchZoom(previousPinchSquaredDistance, pinchSquaredDistance) {
-        const radius = this.camera.radius || ArcRotateCameraPointersInput.MinimumRadiusForPinch;
-        if (this.useNaturalPinchZoom) {
-            this.camera.radius = (radius * Math.sqrt(previousPinchSquaredDistance)) / Math.sqrt(pinchSquaredDistance);
-        }
-        else if (this.pinchDeltaPercentage) {
-            this.camera.inertialRadiusOffset += (pinchSquaredDistance - previousPinchSquaredDistance) * 0.001 * radius * this.pinchDeltaPercentage;
-        }
-        else {
-            this.camera.inertialRadiusOffset +=
-                (pinchSquaredDistance - previousPinchSquaredDistance) /
-                    ((this.pinchPrecision * (this.pinchInwards ? 1 : -1) * (this.angularSensibilityX + this.angularSensibilityY)) / 2);
-        }
-    }
-    /**
-     * Called on pointer POINTERMOVE event if only a single touch is active.
-     * @param point
-     * @param offsetX
-     * @param offsetY
-     */
-    onTouch(point, offsetX, offsetY) {
-        if (this.panningSensibility !== 0 && ((this._ctrlKey && this.camera._useCtrlForPanning) || this._isPanClick)) {
-            this.camera.inertialPanningX += -offsetX / this.panningSensibility;
-            this.camera.inertialPanningY += offsetY / this.panningSensibility;
-        }
-        else {
-            this.camera.inertialAlphaOffset -= offsetX / this.angularSensibilityX;
-            this.camera.inertialBetaOffset -= offsetY / this.angularSensibilityY;
-        }
-    }
-    /**
-     * Called on pointer POINTERDOUBLETAP event.
-     */
-    onDoubleTap() {
-        if (this.camera.useInputToRestoreState) {
-            this.camera.restoreState();
-        }
-    }
-    /**
-     * Called on pointer POINTERMOVE event if multiple touches are active.
-     * @param pointA
-     * @param pointB
-     * @param previousPinchSquaredDistance
-     * @param pinchSquaredDistance
-     * @param previousMultiTouchPanPosition
-     * @param multiTouchPanPosition
-     */
-    onMultiTouch(pointA, pointB, previousPinchSquaredDistance, pinchSquaredDistance, previousMultiTouchPanPosition, multiTouchPanPosition) {
-        if (previousPinchSquaredDistance === 0 && previousMultiTouchPanPosition === null) {
-            // First time this method is called for new pinch.
-            // Next time this is called there will be a
-            // previousPinchSquaredDistance and pinchSquaredDistance to compare.
-            return;
-        }
-        if (pinchSquaredDistance === 0 && multiTouchPanPosition === null) {
-            // Last time this method is called at the end of a pinch.
-            return;
-        }
-        // Zoom and panning enabled together
-        if (this.multiTouchPanAndZoom) {
-            this._computePinchZoom(previousPinchSquaredDistance, pinchSquaredDistance);
-            this._computeMultiTouchPanning(previousMultiTouchPanPosition, multiTouchPanPosition);
-            // Zoom and panning enabled but only one at a time
-        }
-        else if (this.multiTouchPanning && this.pinchZoom) {
-            this._twoFingerActivityCount++;
-            if (this._isPinching ||
-                (this._twoFingerActivityCount < 20 && Math.abs(Math.sqrt(pinchSquaredDistance) - Math.sqrt(previousPinchSquaredDistance)) > this.camera.pinchToPanMaxDistance)) {
-                // Since pinch has not been active long, assume we intend to zoom.
-                this._computePinchZoom(previousPinchSquaredDistance, pinchSquaredDistance);
-                // Since we are pinching, remain pinching on next iteration.
-                this._isPinching = true;
-            }
-            else {
-                // Pause between pinch starting and moving implies not a zoom event. Pan instead.
-                this._computeMultiTouchPanning(previousMultiTouchPanPosition, multiTouchPanPosition);
-            }
-            // Panning enabled, zoom disabled
-        }
-        else if (this.multiTouchPanning) {
-            this._computeMultiTouchPanning(previousMultiTouchPanPosition, multiTouchPanPosition);
-            // Zoom enabled, panning disabled
-        }
-        else if (this.pinchZoom) {
-            this._computePinchZoom(previousPinchSquaredDistance, pinchSquaredDistance);
-        }
-    }
-    /**
-     * Called each time a new POINTERDOWN event occurs. Ie, for each button
-     * press.
-     * @param evt
-     */
-    onButtonDown(evt) {
-        this._isPanClick = evt.button === this.camera._panningMouseButton;
-    }
-    /**
-     * Called each time a new POINTERUP event occurs. Ie, for each button
-     * release.
-     */
-    onButtonUp() {
-        this._twoFingerActivityCount = 0;
-        this._isPinching = false;
-    }
-    /**
-     * Called when window becomes inactive.
-     */
-    onLostFocus() {
-        this._isPanClick = false;
-        this._twoFingerActivityCount = 0;
-        this._isPinching = false;
-    }
-}
-/**
- * The minimum radius used for pinch, to avoid radius lock at 0
- */
-ArcRotateCameraPointersInput.MinimumRadiusForPinch = 0.001;
-__decorate([
-    serialize()
-], ArcRotateCameraPointersInput.prototype, "buttons", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraPointersInput.prototype, "angularSensibilityX", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraPointersInput.prototype, "angularSensibilityY", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraPointersInput.prototype, "pinchPrecision", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraPointersInput.prototype, "pinchDeltaPercentage", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraPointersInput.prototype, "useNaturalPinchZoom", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraPointersInput.prototype, "pinchZoom", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraPointersInput.prototype, "panningSensibility", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraPointersInput.prototype, "multiTouchPanning", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraPointersInput.prototype, "multiTouchPanAndZoom", void 0);
-CameraInputTypes["ArcRotateCameraPointersInput"] = ArcRotateCameraPointersInput;
-
-/**
- * Manage the keyboard inputs to control the movement of an arc rotate camera.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/customizingCameraInputs
- */
-class ArcRotateCameraKeyboardMoveInput {
-    constructor() {
-        /**
-         * Defines the list of key codes associated with the up action (increase alpha)
-         */
-        this.keysUp = [38];
-        /**
-         * Defines the list of key codes associated with the down action (decrease alpha)
-         */
-        this.keysDown = [40];
-        /**
-         * Defines the list of key codes associated with the left action (increase beta)
-         */
-        this.keysLeft = [37];
-        /**
-         * Defines the list of key codes associated with the right action (decrease beta)
-         */
-        this.keysRight = [39];
-        /**
-         * Defines the list of key codes associated with the reset action.
-         * Those keys reset the camera to its last stored state (with the method camera.storeState())
-         */
-        this.keysReset = [220];
-        /**
-         * Defines the panning sensibility of the inputs.
-         * (How fast is the camera panning)
-         */
-        this.panningSensibility = 50.0;
-        /**
-         * Defines the zooming sensibility of the inputs.
-         * (How fast is the camera zooming)
-         */
-        this.zoomingSensibility = 25.0;
-        /**
-         * Defines whether maintaining the alt key down switch the movement mode from
-         * orientation to zoom.
-         */
-        this.useAltToZoom = true;
-        /**
-         * Rotation speed of the camera
-         */
-        this.angularSpeed = 0.01;
-        this._keys = new Array();
-    }
-    /**
-     * Attach the input controls to a specific dom element to get the input from.
-     * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
-     */
-    attachControl(noPreventDefault) {
-        // was there a second variable defined?
-        // eslint-disable-next-line prefer-rest-params
-        noPreventDefault = Tools.BackCompatCameraNoPreventDefault(arguments);
-        if (this._onCanvasBlurObserver) {
-            return;
-        }
-        this._scene = this.camera.getScene();
-        this._engine = this._scene.getEngine();
-        this._onCanvasBlurObserver = this._engine.onCanvasBlurObservable.add(() => {
-            this._keys.length = 0;
-        });
-        this._onKeyboardObserver = this._scene.onKeyboardObservable.add((info) => {
-            const evt = info.event;
-            if (!evt.metaKey) {
-                if (info.type === KeyboardEventTypes.KEYDOWN) {
-                    this._ctrlPressed = evt.ctrlKey;
-                    this._altPressed = evt.altKey;
-                    if (this.keysUp.indexOf(evt.keyCode) !== -1 ||
-                        this.keysDown.indexOf(evt.keyCode) !== -1 ||
-                        this.keysLeft.indexOf(evt.keyCode) !== -1 ||
-                        this.keysRight.indexOf(evt.keyCode) !== -1 ||
-                        this.keysReset.indexOf(evt.keyCode) !== -1) {
-                        const index = this._keys.indexOf(evt.keyCode);
-                        if (index === -1) {
-                            this._keys.push(evt.keyCode);
-                        }
-                        if (evt.preventDefault) {
-                            if (!noPreventDefault) {
-                                evt.preventDefault();
-                            }
-                        }
-                    }
-                }
-                else {
-                    if (this.keysUp.indexOf(evt.keyCode) !== -1 ||
-                        this.keysDown.indexOf(evt.keyCode) !== -1 ||
-                        this.keysLeft.indexOf(evt.keyCode) !== -1 ||
-                        this.keysRight.indexOf(evt.keyCode) !== -1 ||
-                        this.keysReset.indexOf(evt.keyCode) !== -1) {
-                        const index = this._keys.indexOf(evt.keyCode);
-                        if (index >= 0) {
-                            this._keys.splice(index, 1);
-                        }
-                        if (evt.preventDefault) {
-                            if (!noPreventDefault) {
-                                evt.preventDefault();
-                            }
-                        }
-                    }
-                }
-            }
-        });
-    }
-    /**
-     * Detach the current controls from the specified dom element.
-     */
-    detachControl() {
-        if (this._scene) {
-            if (this._onKeyboardObserver) {
-                this._scene.onKeyboardObservable.remove(this._onKeyboardObserver);
-            }
-            if (this._onCanvasBlurObserver) {
-                this._engine.onCanvasBlurObservable.remove(this._onCanvasBlurObserver);
-            }
-            this._onKeyboardObserver = null;
-            this._onCanvasBlurObserver = null;
-        }
-        this._keys.length = 0;
-    }
-    /**
-     * Update the current camera state depending on the inputs that have been used this frame.
-     * This is a dynamically created lambda to avoid the performance penalty of looping for inputs in the render loop.
-     */
-    checkInputs() {
-        if (this._onKeyboardObserver) {
-            const camera = this.camera;
-            for (let index = 0; index < this._keys.length; index++) {
-                const keyCode = this._keys[index];
-                if (this.keysLeft.indexOf(keyCode) !== -1) {
-                    if (this._ctrlPressed && this.camera._useCtrlForPanning) {
-                        camera.inertialPanningX -= 1 / this.panningSensibility;
-                    }
-                    else {
-                        camera.inertialAlphaOffset -= this.angularSpeed;
-                    }
-                }
-                else if (this.keysUp.indexOf(keyCode) !== -1) {
-                    if (this._ctrlPressed && this.camera._useCtrlForPanning) {
-                        camera.inertialPanningY += 1 / this.panningSensibility;
-                    }
-                    else if (this._altPressed && this.useAltToZoom) {
-                        camera.inertialRadiusOffset += 1 / this.zoomingSensibility;
-                    }
-                    else {
-                        camera.inertialBetaOffset -= this.angularSpeed;
-                    }
-                }
-                else if (this.keysRight.indexOf(keyCode) !== -1) {
-                    if (this._ctrlPressed && this.camera._useCtrlForPanning) {
-                        camera.inertialPanningX += 1 / this.panningSensibility;
-                    }
-                    else {
-                        camera.inertialAlphaOffset += this.angularSpeed;
-                    }
-                }
-                else if (this.keysDown.indexOf(keyCode) !== -1) {
-                    if (this._ctrlPressed && this.camera._useCtrlForPanning) {
-                        camera.inertialPanningY -= 1 / this.panningSensibility;
-                    }
-                    else if (this._altPressed && this.useAltToZoom) {
-                        camera.inertialRadiusOffset -= 1 / this.zoomingSensibility;
-                    }
-                    else {
-                        camera.inertialBetaOffset += this.angularSpeed;
-                    }
-                }
-                else if (this.keysReset.indexOf(keyCode) !== -1) {
-                    if (camera.useInputToRestoreState) {
-                        camera.restoreState();
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Gets the class name of the current input.
-     * @returns the class name
-     */
-    getClassName() {
-        return "ArcRotateCameraKeyboardMoveInput";
-    }
-    /**
-     * Get the friendly name associated with the input class.
-     * @returns the input friendly name
-     */
-    getSimpleName() {
-        return "keyboard";
-    }
-}
-__decorate([
-    serialize()
-], ArcRotateCameraKeyboardMoveInput.prototype, "keysUp", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraKeyboardMoveInput.prototype, "keysDown", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraKeyboardMoveInput.prototype, "keysLeft", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraKeyboardMoveInput.prototype, "keysRight", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraKeyboardMoveInput.prototype, "keysReset", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraKeyboardMoveInput.prototype, "panningSensibility", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraKeyboardMoveInput.prototype, "zoomingSensibility", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraKeyboardMoveInput.prototype, "useAltToZoom", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraKeyboardMoveInput.prototype, "angularSpeed", void 0);
-CameraInputTypes["ArcRotateCameraKeyboardMoveInput"] = ArcRotateCameraKeyboardMoveInput;
-
-/**
- * Firefox uses a different scheme to report scroll distances to other
- * browsers. Rather than use complicated methods to calculate the exact
- * multiple we need to apply, let's just cheat and use a constant.
- * https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaMode
- * https://stackoverflow.com/questions/20110224/what-is-the-height-of-a-line-in-a-wheel-event-deltamode-dom-delta-line
- */
-const ffMultiplier = 40;
-/**
- * Manage the mouse wheel inputs to control an arc rotate camera.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/customizingCameraInputs
- */
-class ArcRotateCameraMouseWheelInput {
-    constructor() {
-        /**
-         * Gets or Set the mouse wheel precision or how fast is the camera zooming.
-         */
-        this.wheelPrecision = 3.0;
-        /**
-         * Gets or Set the boolean value that controls whether or not the mouse wheel
-         * zooms to the location of the mouse pointer or not.  The default is false.
-         */
-        this.zoomToMouseLocation = false;
-        /**
-         * wheelDeltaPercentage will be used instead of wheelPrecision if different from 0.
-         * It defines the percentage of current camera.radius to use as delta when wheel is used.
-         */
-        this.wheelDeltaPercentage = 0;
-        /**
-         * If set, this function will be used to set the radius delta that will be added to the current camera radius
-         */
-        this.customComputeDeltaFromMouseWheel = null;
-        this._inertialPanning = Vector3.Zero();
-    }
-    _computeDeltaFromMouseWheelLegacyEvent(mouseWheelDelta, radius) {
-        let delta = 0;
-        const wheelDelta = mouseWheelDelta * 0.01 * this.wheelDeltaPercentage * radius;
-        if (mouseWheelDelta > 0) {
-            delta = wheelDelta / (1.0 + this.wheelDeltaPercentage);
-        }
-        else {
-            delta = wheelDelta * (1.0 + this.wheelDeltaPercentage);
-        }
-        return delta;
-    }
-    /**
-     * Attach the input controls to a specific dom element to get the input from.
-     * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
-     */
-    attachControl(noPreventDefault) {
-        noPreventDefault = Tools.BackCompatCameraNoPreventDefault(arguments);
-        this._wheel = (p) => {
-            //sanity check - this should be a PointerWheel event.
-            if (p.type !== PointerEventTypes.POINTERWHEEL) {
-                return;
-            }
-            const event = p.event;
-            let delta = 0;
-            const platformScale = event.deltaMode === EventConstants.DOM_DELTA_LINE ? ffMultiplier : 1; // If this happens to be set to DOM_DELTA_LINE, adjust accordingly
-            const wheelDelta = -(event.deltaY * platformScale);
-            if (this.customComputeDeltaFromMouseWheel) {
-                delta = this.customComputeDeltaFromMouseWheel(wheelDelta, this, event);
-            }
-            else {
-                if (this.wheelDeltaPercentage) {
-                    delta = this._computeDeltaFromMouseWheelLegacyEvent(wheelDelta, this.camera.radius);
-                    // If zooming in, estimate the target radius and use that to compute the delta for inertia
-                    // this will stop multiple scroll events zooming in from adding too much inertia
-                    if (delta > 0) {
-                        let estimatedTargetRadius = this.camera.radius;
-                        let targetInertia = this.camera.inertialRadiusOffset + delta;
-                        for (let i = 0; i < 20 && Math.abs(targetInertia) > 0.001; i++) {
-                            estimatedTargetRadius -= targetInertia;
-                            targetInertia *= this.camera.inertia;
-                        }
-                        estimatedTargetRadius = Scalar.Clamp(estimatedTargetRadius, 0, Number.MAX_VALUE);
-                        delta = this._computeDeltaFromMouseWheelLegacyEvent(wheelDelta, estimatedTargetRadius);
-                    }
-                }
-                else {
-                    delta = wheelDelta / (this.wheelPrecision * 40);
-                }
-            }
-            if (delta) {
-                if (this.zoomToMouseLocation) {
-                    // If we are zooming to the mouse location, then we need to get the hit plane at the start of the zoom gesture if it doesn't exist
-                    // The hit plane is normally calculated after the first motion and each time there's motion so if we don't do this first,
-                    // the first zoom will be to the center of the screen
-                    if (!this._hitPlane) {
-                        this._updateHitPlane();
-                    }
-                    this._zoomToMouse(delta);
-                }
-                else {
-                    this.camera.inertialRadiusOffset += delta;
-                }
-            }
-            if (event.preventDefault) {
-                if (!noPreventDefault) {
-                    event.preventDefault();
-                }
-            }
-        };
-        this._observer = this.camera.getScene()._inputManager._addCameraPointerObserver(this._wheel, PointerEventTypes.POINTERWHEEL);
-        if (this.zoomToMouseLocation) {
-            this._inertialPanning.setAll(0);
-        }
-    }
-    /**
-     * Detach the current controls from the specified dom element.
-     */
-    detachControl() {
-        if (this._observer) {
-            this.camera.getScene()._inputManager._removeCameraPointerObserver(this._observer);
-            this._observer = null;
-            this._wheel = null;
-        }
-    }
-    /**
-     * Update the current camera state depending on the inputs that have been used this frame.
-     * This is a dynamically created lambda to avoid the performance penalty of looping for inputs in the render loop.
-     */
-    checkInputs() {
-        if (!this.zoomToMouseLocation) {
-            return;
-        }
-        const camera = this.camera;
-        const motion = 0.0 + camera.inertialAlphaOffset + camera.inertialBetaOffset + camera.inertialRadiusOffset;
-        if (motion) {
-            // if zooming is still happening as a result of inertia, then we also need to update
-            // the hit plane.
-            this._updateHitPlane();
-            // Note we cannot  use arcRotateCamera.inertialPlanning here because arcRotateCamera panning
-            // uses a different panningInertia which could cause this panning to get out of sync with
-            // the zooming, and for this to work they must be exactly in sync.
-            camera.target.addInPlace(this._inertialPanning);
-            this._inertialPanning.scaleInPlace(camera.inertia);
-            this._zeroIfClose(this._inertialPanning);
-        }
-    }
-    /**
-     * Gets the class name of the current input.
-     * @returns the class name
-     */
-    getClassName() {
-        return "ArcRotateCameraMouseWheelInput";
-    }
-    /**
-     * Get the friendly name associated with the input class.
-     * @returns the input friendly name
-     */
-    getSimpleName() {
-        return "mousewheel";
-    }
-    _updateHitPlane() {
-        const camera = this.camera;
-        const direction = camera.target.subtract(camera.position);
-        this._hitPlane = Plane.FromPositionAndNormal(camera.target, direction);
-    }
-    // Get position on the hit plane
-    _getPosition() {
-        var _a;
-        const camera = this.camera;
-        const scene = camera.getScene();
-        // since the _hitPlane is always updated to be orthogonal to the camera position vector
-        // we don't have to worry about this ray shooting off to infinity. This ray creates
-        // a vector defining where we want to zoom to.
-        const ray = scene.createPickingRay(scene.pointerX, scene.pointerY, Matrix.Identity(), camera, false);
-        // Since the camera is the origin of the picking ray, we need to offset it by the camera's offset manually
-        ray.origin.x -= camera.targetScreenOffset.x;
-        ray.origin.y -= camera.targetScreenOffset.y;
-        let distance = 0;
-        if (this._hitPlane) {
-            distance = (_a = ray.intersectsPlane(this._hitPlane)) !== null && _a !== void 0 ? _a : 0;
-        }
-        // not using this ray again, so modifying its vectors here is fine
-        return ray.origin.addInPlace(ray.direction.scaleInPlace(distance));
-    }
-    _zoomToMouse(delta) {
-        var _a, _b;
-        const camera = this.camera;
-        const inertiaComp = 1 - camera.inertia;
-        if (camera.lowerRadiusLimit) {
-            const lowerLimit = (_a = camera.lowerRadiusLimit) !== null && _a !== void 0 ? _a : 0;
-            if (camera.radius - (camera.inertialRadiusOffset + delta) / inertiaComp < lowerLimit) {
-                delta = (camera.radius - lowerLimit) * inertiaComp - camera.inertialRadiusOffset;
-            }
-        }
-        if (camera.upperRadiusLimit) {
-            const upperLimit = (_b = camera.upperRadiusLimit) !== null && _b !== void 0 ? _b : 0;
-            if (camera.radius - (camera.inertialRadiusOffset + delta) / inertiaComp > upperLimit) {
-                delta = (camera.radius - upperLimit) * inertiaComp - camera.inertialRadiusOffset;
-            }
-        }
-        const zoomDistance = delta / inertiaComp;
-        const ratio = zoomDistance / camera.radius;
-        const vec = this._getPosition();
-        // Now this vector tells us how much we also need to pan the camera
-        // so the targeted mouse location becomes the center of zooming.
-        const directionToZoomLocation = TmpVectors.Vector3[6];
-        vec.subtractToRef(camera.target, directionToZoomLocation);
-        directionToZoomLocation.scaleInPlace(ratio);
-        directionToZoomLocation.scaleInPlace(inertiaComp);
-        this._inertialPanning.addInPlace(directionToZoomLocation);
-        camera.inertialRadiusOffset += delta;
-    }
-    // Sets x y or z of passed in vector to zero if less than Epsilon.
-    _zeroIfClose(vec) {
-        if (Math.abs(vec.x) < Epsilon) {
-            vec.x = 0;
-        }
-        if (Math.abs(vec.y) < Epsilon) {
-            vec.y = 0;
-        }
-        if (Math.abs(vec.z) < Epsilon) {
-            vec.z = 0;
-        }
-    }
-}
-__decorate([
-    serialize()
-], ArcRotateCameraMouseWheelInput.prototype, "wheelPrecision", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraMouseWheelInput.prototype, "zoomToMouseLocation", void 0);
-__decorate([
-    serialize()
-], ArcRotateCameraMouseWheelInput.prototype, "wheelDeltaPercentage", void 0);
-CameraInputTypes["ArcRotateCameraMouseWheelInput"] = ArcRotateCameraMouseWheelInput;
-
-/**
- * Default Inputs manager for the ArcRotateCamera.
- * It groups all the default supported inputs for ease of use.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/customizingCameraInputs
- */
-class ArcRotateCameraInputsManager extends CameraInputsManager {
-    /**
-     * Instantiates a new ArcRotateCameraInputsManager.
-     * @param camera Defines the camera the inputs belong to
-     */
-    constructor(camera) {
-        super(camera);
-    }
-    /**
-     * Add mouse wheel input support to the input manager.
-     * @returns the current input manager
-     */
-    addMouseWheel() {
-        this.add(new ArcRotateCameraMouseWheelInput());
-        return this;
-    }
-    /**
-     * Add pointers input support to the input manager.
-     * @returns the current input manager
-     */
-    addPointers() {
-        this.add(new ArcRotateCameraPointersInput());
-        return this;
-    }
-    /**
-     * Add keyboard input support to the input manager.
-     * @returns the current input manager
-     */
-    addKeyboard() {
-        this.add(new ArcRotateCameraKeyboardMoveInput());
-        return this;
-    }
-}
-
-Node.AddNodeConstructor("ArcRotateCamera", (name, scene) => {
-    return () => new ArcRotateCamera(name, 0, 0, 1.0, Vector3.Zero(), scene);
-});
-/**
- * This represents an orbital type of camera.
- *
- * This camera always points towards a given target position and can be rotated around that target with the target as the centre of rotation. It can be controlled with cursors and mouse, or with touch events.
- * Think of this camera as one orbiting its target position, or more imaginatively as a spy satellite orbiting the earth. Its position relative to the target (earth) can be set by three parameters, alpha (radians) the longitudinal rotation, beta (radians) the latitudinal rotation and radius the distance from the target position.
- * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/camera_introduction#arc-rotate-camera
- */
-class ArcRotateCamera extends TargetCamera {
-    /**
-     * Defines the target point of the camera.
-     * The camera looks towards it from the radius distance.
-     */
-    get target() {
-        return this._target;
-    }
-    set target(value) {
-        this.setTarget(value);
-    }
-    /**
-     * Defines the target mesh of the camera.
-     * The camera looks towards it from the radius distance.
-     * Please note that setting a target host will disable panning.
-     */
-    get targetHost() {
-        return this._targetHost;
-    }
-    set targetHost(value) {
-        if (value) {
-            this.setTarget(value);
-        }
-    }
-    /**
-     * Return the current target position of the camera. This value is expressed in local space.
-     * @returns the target position
-     */
-    getTarget() {
-        return this.target;
-    }
-    /**
-     * Define the current local position of the camera in the scene
-     */
-    get position() {
-        return this._position;
-    }
-    set position(newPosition) {
-        this.setPosition(newPosition);
-    }
-    /**
-     * The vector the camera should consider as up. (default is Vector3(0, 1, 0) as returned by Vector3.Up())
-     * Setting this will copy the given vector to the camera's upVector, and set rotation matrices to and from Y up.
-     * DO NOT set the up vector using copyFrom or copyFromFloats, as this bypasses setting the above matrices.
-     */
-    set upVector(vec) {
-        if (!this._upToYMatrix) {
-            this._yToUpMatrix = new Matrix();
-            this._upToYMatrix = new Matrix();
-            this._upVector = Vector3.Zero();
-        }
-        vec.normalize();
-        this._upVector.copyFrom(vec);
-        this.setMatUp();
-    }
-    get upVector() {
-        return this._upVector;
-    }
-    /**
-     * Sets the Y-up to camera up-vector rotation matrix, and the up-vector to Y-up rotation matrix.
-     */
-    setMatUp() {
-        // from y-up to custom-up (used in _getViewMatrix)
-        Matrix.RotationAlignToRef(Vector3.UpReadOnly, this._upVector, this._yToUpMatrix);
-        // from custom-up to y-up (used in rebuildAnglesAndRadius)
-        Matrix.RotationAlignToRef(this._upVector, Vector3.UpReadOnly, this._upToYMatrix);
-    }
-    //-- begin properties for backward compatibility for inputs
-    /**
-     * Gets or Set the pointer angular sensibility  along the X axis or how fast is the camera rotating.
-     */
-    get angularSensibilityX() {
-        const pointers = this.inputs.attached["pointers"];
-        if (pointers) {
-            return pointers.angularSensibilityX;
-        }
-        return 0;
-    }
-    set angularSensibilityX(value) {
-        const pointers = this.inputs.attached["pointers"];
-        if (pointers) {
-            pointers.angularSensibilityX = value;
-        }
-    }
-    /**
-     * Gets or Set the pointer angular sensibility along the Y axis or how fast is the camera rotating.
-     */
-    get angularSensibilityY() {
-        const pointers = this.inputs.attached["pointers"];
-        if (pointers) {
-            return pointers.angularSensibilityY;
-        }
-        return 0;
-    }
-    set angularSensibilityY(value) {
-        const pointers = this.inputs.attached["pointers"];
-        if (pointers) {
-            pointers.angularSensibilityY = value;
-        }
-    }
-    /**
-     * Gets or Set the pointer pinch precision or how fast is the camera zooming.
-     */
-    get pinchPrecision() {
-        const pointers = this.inputs.attached["pointers"];
-        if (pointers) {
-            return pointers.pinchPrecision;
-        }
-        return 0;
-    }
-    set pinchPrecision(value) {
-        const pointers = this.inputs.attached["pointers"];
-        if (pointers) {
-            pointers.pinchPrecision = value;
-        }
-    }
-    /**
-     * Gets or Set the pointer pinch delta percentage or how fast is the camera zooming.
-     * It will be used instead of pinchDeltaPrecision if different from 0.
-     * It defines the percentage of current camera.radius to use as delta when pinch zoom is used.
-     */
-    get pinchDeltaPercentage() {
-        const pointers = this.inputs.attached["pointers"];
-        if (pointers) {
-            return pointers.pinchDeltaPercentage;
-        }
-        return 0;
-    }
-    set pinchDeltaPercentage(value) {
-        const pointers = this.inputs.attached["pointers"];
-        if (pointers) {
-            pointers.pinchDeltaPercentage = value;
-        }
-    }
-    /**
-     * Gets or Set the pointer use natural pinch zoom to override the pinch precision
-     * and pinch delta percentage.
-     * When useNaturalPinchZoom is true, multi touch zoom will zoom in such
-     * that any object in the plane at the camera's target point will scale
-     * perfectly with finger motion.
-     */
-    get useNaturalPinchZoom() {
-        const pointers = this.inputs.attached["pointers"];
-        if (pointers) {
-            return pointers.useNaturalPinchZoom;
-        }
-        return false;
-    }
-    set useNaturalPinchZoom(value) {
-        const pointers = this.inputs.attached["pointers"];
-        if (pointers) {
-            pointers.useNaturalPinchZoom = value;
-        }
-    }
-    /**
-     * Gets or Set the pointer panning sensibility or how fast is the camera moving.
-     */
-    get panningSensibility() {
-        const pointers = this.inputs.attached["pointers"];
-        if (pointers) {
-            return pointers.panningSensibility;
-        }
-        return 0;
-    }
-    set panningSensibility(value) {
-        const pointers = this.inputs.attached["pointers"];
-        if (pointers) {
-            pointers.panningSensibility = value;
-        }
-    }
-    /**
-     * Gets or Set the list of keyboard keys used to control beta angle in a positive direction.
-     */
-    get keysUp() {
-        const keyboard = this.inputs.attached["keyboard"];
-        if (keyboard) {
-            return keyboard.keysUp;
-        }
-        return [];
-    }
-    set keysUp(value) {
-        const keyboard = this.inputs.attached["keyboard"];
-        if (keyboard) {
-            keyboard.keysUp = value;
-        }
-    }
-    /**
-     * Gets or Set the list of keyboard keys used to control beta angle in a negative direction.
-     */
-    get keysDown() {
-        const keyboard = this.inputs.attached["keyboard"];
-        if (keyboard) {
-            return keyboard.keysDown;
-        }
-        return [];
-    }
-    set keysDown(value) {
-        const keyboard = this.inputs.attached["keyboard"];
-        if (keyboard) {
-            keyboard.keysDown = value;
-        }
-    }
-    /**
-     * Gets or Set the list of keyboard keys used to control alpha angle in a negative direction.
-     */
-    get keysLeft() {
-        const keyboard = this.inputs.attached["keyboard"];
-        if (keyboard) {
-            return keyboard.keysLeft;
-        }
-        return [];
-    }
-    set keysLeft(value) {
-        const keyboard = this.inputs.attached["keyboard"];
-        if (keyboard) {
-            keyboard.keysLeft = value;
-        }
-    }
-    /**
-     * Gets or Set the list of keyboard keys used to control alpha angle in a positive direction.
-     */
-    get keysRight() {
-        const keyboard = this.inputs.attached["keyboard"];
-        if (keyboard) {
-            return keyboard.keysRight;
-        }
-        return [];
-    }
-    set keysRight(value) {
-        const keyboard = this.inputs.attached["keyboard"];
-        if (keyboard) {
-            keyboard.keysRight = value;
-        }
-    }
-    /**
-     * Gets or Set the mouse wheel precision or how fast is the camera zooming.
-     */
-    get wheelPrecision() {
-        const mousewheel = this.inputs.attached["mousewheel"];
-        if (mousewheel) {
-            return mousewheel.wheelPrecision;
-        }
-        return 0;
-    }
-    set wheelPrecision(value) {
-        const mousewheel = this.inputs.attached["mousewheel"];
-        if (mousewheel) {
-            mousewheel.wheelPrecision = value;
-        }
-    }
-    /**
-     * Gets or Set the boolean value that controls whether or not the mouse wheel
-     * zooms to the location of the mouse pointer or not.  The default is false.
-     */
-    get zoomToMouseLocation() {
-        const mousewheel = this.inputs.attached["mousewheel"];
-        if (mousewheel) {
-            return mousewheel.zoomToMouseLocation;
-        }
-        return false;
-    }
-    set zoomToMouseLocation(value) {
-        const mousewheel = this.inputs.attached["mousewheel"];
-        if (mousewheel) {
-            mousewheel.zoomToMouseLocation = value;
-        }
-    }
-    /**
-     * Gets or Set the mouse wheel delta percentage or how fast is the camera zooming.
-     * It will be used instead of pinchDeltaPrecision if different from 0.
-     * It defines the percentage of current camera.radius to use as delta when pinch zoom is used.
-     */
-    get wheelDeltaPercentage() {
-        const mousewheel = this.inputs.attached["mousewheel"];
-        if (mousewheel) {
-            return mousewheel.wheelDeltaPercentage;
-        }
-        return 0;
-    }
-    set wheelDeltaPercentage(value) {
-        const mousewheel = this.inputs.attached["mousewheel"];
-        if (mousewheel) {
-            mousewheel.wheelDeltaPercentage = value;
-        }
-    }
-    /**
-     * Gets the bouncing behavior of the camera if it has been enabled.
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/behaviors/cameraBehaviors#bouncing-behavior
-     */
-    get bouncingBehavior() {
-        return this._bouncingBehavior;
-    }
-    /**
-     * Defines if the bouncing behavior of the camera is enabled on the camera.
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/behaviors/cameraBehaviors#bouncing-behavior
-     */
-    get useBouncingBehavior() {
-        return this._bouncingBehavior != null;
-    }
-    set useBouncingBehavior(value) {
-        if (value === this.useBouncingBehavior) {
-            return;
-        }
-        if (value) {
-            this._bouncingBehavior = new BouncingBehavior();
-            this.addBehavior(this._bouncingBehavior);
-        }
-        else if (this._bouncingBehavior) {
-            this.removeBehavior(this._bouncingBehavior);
-            this._bouncingBehavior = null;
-        }
-    }
-    /**
-     * Gets the framing behavior of the camera if it has been enabled.
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/behaviors/cameraBehaviors#framing-behavior
-     */
-    get framingBehavior() {
-        return this._framingBehavior;
-    }
-    /**
-     * Defines if the framing behavior of the camera is enabled on the camera.
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/behaviors/cameraBehaviors#framing-behavior
-     */
-    get useFramingBehavior() {
-        return this._framingBehavior != null;
-    }
-    set useFramingBehavior(value) {
-        if (value === this.useFramingBehavior) {
-            return;
-        }
-        if (value) {
-            this._framingBehavior = new FramingBehavior();
-            this.addBehavior(this._framingBehavior);
-        }
-        else if (this._framingBehavior) {
-            this.removeBehavior(this._framingBehavior);
-            this._framingBehavior = null;
-        }
-    }
-    /**
-     * Gets the auto rotation behavior of the camera if it has been enabled.
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/behaviors/cameraBehaviors#autorotation-behavior
-     */
-    get autoRotationBehavior() {
-        return this._autoRotationBehavior;
-    }
-    /**
-     * Defines if the auto rotation behavior of the camera is enabled on the camera.
-     * @see https://doc.babylonjs.com/features/featuresDeepDive/behaviors/cameraBehaviors#autorotation-behavior
-     */
-    get useAutoRotationBehavior() {
-        return this._autoRotationBehavior != null;
-    }
-    set useAutoRotationBehavior(value) {
-        if (value === this.useAutoRotationBehavior) {
-            return;
-        }
-        if (value) {
-            this._autoRotationBehavior = new AutoRotationBehavior();
-            this.addBehavior(this._autoRotationBehavior);
-        }
-        else if (this._autoRotationBehavior) {
-            this.removeBehavior(this._autoRotationBehavior);
-            this._autoRotationBehavior = null;
-        }
-    }
-    /**
-     * Instantiates a new ArcRotateCamera in a given scene
-     * @param name Defines the name of the camera
-     * @param alpha Defines the camera rotation along the longitudinal axis
-     * @param beta Defines the camera rotation along the latitudinal axis
-     * @param radius Defines the camera distance from its target
-     * @param target Defines the camera target
-     * @param scene Defines the scene the camera belongs to
-     * @param setActiveOnSceneIfNoneActive Defines whether the camera should be marked as active if not other active cameras have been defined
-     */
-    constructor(name, alpha, beta, radius, target, scene, setActiveOnSceneIfNoneActive = true) {
-        super(name, Vector3.Zero(), scene, setActiveOnSceneIfNoneActive);
-        /**
-         * Current inertia value on the longitudinal axis.
-         * The bigger this number the longer it will take for the camera to stop.
-         */
-        this.inertialAlphaOffset = 0;
-        /**
-         * Current inertia value on the latitudinal axis.
-         * The bigger this number the longer it will take for the camera to stop.
-         */
-        this.inertialBetaOffset = 0;
-        /**
-         * Current inertia value on the radius axis.
-         * The bigger this number the longer it will take for the camera to stop.
-         */
-        this.inertialRadiusOffset = 0;
-        /**
-         * Minimum allowed angle on the longitudinal axis.
-         * This can help limiting how the Camera is able to move in the scene.
-         */
-        this.lowerAlphaLimit = null;
-        /**
-         * Maximum allowed angle on the longitudinal axis.
-         * This can help limiting how the Camera is able to move in the scene.
-         */
-        this.upperAlphaLimit = null;
-        /**
-         * Minimum allowed angle on the latitudinal axis.
-         * This can help limiting how the Camera is able to move in the scene.
-         */
-        this.lowerBetaLimit = 0.01;
-        /**
-         * Maximum allowed angle on the latitudinal axis.
-         * This can help limiting how the Camera is able to move in the scene.
-         */
-        this.upperBetaLimit = Math.PI - 0.01;
-        /**
-         * Minimum allowed distance of the camera to the target (The camera can not get closer).
-         * This can help limiting how the Camera is able to move in the scene.
-         */
-        this.lowerRadiusLimit = null;
-        /**
-         * Maximum allowed distance of the camera to the target (The camera can not get further).
-         * This can help limiting how the Camera is able to move in the scene.
-         */
-        this.upperRadiusLimit = null;
-        /**
-         * Defines the current inertia value used during panning of the camera along the X axis.
-         */
-        this.inertialPanningX = 0;
-        /**
-         * Defines the current inertia value used during panning of the camera along the Y axis.
-         */
-        this.inertialPanningY = 0;
-        /**
-         * Defines the distance used to consider the camera in pan mode vs pinch/zoom.
-         * Basically if your fingers moves away from more than this distance you will be considered
-         * in pinch mode.
-         */
-        this.pinchToPanMaxDistance = 20;
-        /**
-         * Defines the maximum distance the camera can pan.
-         * This could help keeping the camera always in your scene.
-         */
-        this.panningDistanceLimit = null;
-        /**
-         * Defines the target of the camera before panning.
-         */
-        this.panningOriginTarget = Vector3.Zero();
-        /**
-         * Defines the value of the inertia used during panning.
-         * 0 would mean stop inertia and one would mean no deceleration at all.
-         */
-        this.panningInertia = 0.9;
-        //-- end properties for backward compatibility for inputs
-        /**
-         * Defines how much the radius should be scaled while zooming on a particular mesh (through the zoomOn function)
-         */
-        this.zoomOnFactor = 1;
-        /**
-         * Defines a screen offset for the camera position.
-         */
-        this.targetScreenOffset = Vector2.Zero();
-        /**
-         * Allows the camera to be completely reversed.
-         * If false the camera can not arrive upside down.
-         */
-        this.allowUpsideDown = true;
-        /**
-         * Define if double tap/click is used to restore the previously saved state of the camera.
-         */
-        this.useInputToRestoreState = true;
-        /** @internal */
-        this._viewMatrix = new Matrix();
-        /**
-         * Defines the allowed panning axis.
-         */
-        this.panningAxis = new Vector3(1, 1, 0);
-        this._transformedDirection = new Vector3();
-        /**
-         * Defines if camera will eliminate transform on y axis.
-         */
-        this.mapPanning = false;
-        /**
-         * Observable triggered when the mesh target has been changed on the camera.
-         */
-        this.onMeshTargetChangedObservable = new Observable();
-        /**
-         * Defines whether the camera should check collision with the objects oh the scene.
-         * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/camera_collisions#how-can-i-do-this-
-         */
-        this.checkCollisions = false;
-        /**
-         * Defines the collision radius of the camera.
-         * This simulates a sphere around the camera.
-         * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/camera_collisions#arcrotatecamera
-         */
-        this.collisionRadius = new Vector3(0.5, 0.5, 0.5);
-        this._previousPosition = Vector3.Zero();
-        this._collisionVelocity = Vector3.Zero();
-        this._newPosition = Vector3.Zero();
-        this._computationVector = Vector3.Zero();
-        this._onCollisionPositionChange = (collisionId, newPosition, collidedMesh = null) => {
-            if (!collidedMesh) {
-                this._previousPosition.copyFrom(this._position);
-            }
-            else {
-                this.setPosition(newPosition);
-                if (this.onCollide) {
-                    this.onCollide(collidedMesh);
-                }
-            }
-            // Recompute because of constraints
-            const cosa = Math.cos(this.alpha);
-            const sina = Math.sin(this.alpha);
-            const cosb = Math.cos(this.beta);
-            let sinb = Math.sin(this.beta);
-            if (sinb === 0) {
-                sinb = 0.0001;
-            }
-            const target = this._getTargetPosition();
-            this._computationVector.copyFromFloats(this.radius * cosa * sinb, this.radius * cosb, this.radius * sina * sinb);
-            target.addToRef(this._computationVector, this._newPosition);
-            this._position.copyFrom(this._newPosition);
-            let up = this.upVector;
-            if (this.allowUpsideDown && this.beta < 0) {
-                up = up.clone();
-                up = up.negate();
-            }
-            this._computeViewMatrix(this._position, target, up);
-            this._viewMatrix.addAtIndex(12, this.targetScreenOffset.x);
-            this._viewMatrix.addAtIndex(13, this.targetScreenOffset.y);
-            this._collisionTriggered = false;
-        };
-        this._target = Vector3.Zero();
-        if (target) {
-            this.setTarget(target);
-        }
-        this.alpha = alpha;
-        this.beta = beta;
-        this.radius = radius;
-        this.getViewMatrix();
-        this.inputs = new ArcRotateCameraInputsManager(this);
-        this.inputs.addKeyboard().addMouseWheel().addPointers();
-    }
-    // Cache
-    /** @internal */
-    _initCache() {
-        super._initCache();
-        this._cache._target = new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-        this._cache.alpha = undefined;
-        this._cache.beta = undefined;
-        this._cache.radius = undefined;
-        this._cache.targetScreenOffset = Vector2.Zero();
-    }
-    /**
-     * @internal
-     */
-    _updateCache(ignoreParentClass) {
-        if (!ignoreParentClass) {
-            super._updateCache();
-        }
-        this._cache._target.copyFrom(this._getTargetPosition());
-        this._cache.alpha = this.alpha;
-        this._cache.beta = this.beta;
-        this._cache.radius = this.radius;
-        this._cache.targetScreenOffset.copyFrom(this.targetScreenOffset);
-    }
-    _getTargetPosition() {
-        if (this._targetHost && this._targetHost.getAbsolutePosition) {
-            const pos = this._targetHost.getAbsolutePosition();
-            if (this._targetBoundingCenter) {
-                pos.addToRef(this._targetBoundingCenter, this._target);
-            }
-            else {
-                this._target.copyFrom(pos);
-            }
-        }
-        const lockedTargetPosition = this._getLockedTargetPosition();
-        if (lockedTargetPosition) {
-            return lockedTargetPosition;
-        }
-        return this._target;
-    }
-    /**
-     * Stores the current state of the camera (alpha, beta, radius and target)
-     * @returns the camera itself
-     */
-    storeState() {
-        this._storedAlpha = this.alpha;
-        this._storedBeta = this.beta;
-        this._storedRadius = this.radius;
-        this._storedTarget = this._getTargetPosition().clone();
-        this._storedTargetScreenOffset = this.targetScreenOffset.clone();
-        return super.storeState();
-    }
-    /**
-     * @internal
-     * Restored camera state. You must call storeState() first
-     */
-    _restoreStateValues() {
-        if (!super._restoreStateValues()) {
-            return false;
-        }
-        this.setTarget(this._storedTarget.clone());
-        this.alpha = this._storedAlpha;
-        this.beta = this._storedBeta;
-        this.radius = this._storedRadius;
-        this.targetScreenOffset = this._storedTargetScreenOffset.clone();
-        this.inertialAlphaOffset = 0;
-        this.inertialBetaOffset = 0;
-        this.inertialRadiusOffset = 0;
-        this.inertialPanningX = 0;
-        this.inertialPanningY = 0;
-        return true;
-    }
-    // Synchronized
-    /** @internal */
-    _isSynchronizedViewMatrix() {
-        if (!super._isSynchronizedViewMatrix()) {
-            return false;
-        }
-        return (this._cache._target.equals(this._getTargetPosition()) &&
-            this._cache.alpha === this.alpha &&
-            this._cache.beta === this.beta &&
-            this._cache.radius === this.radius &&
-            this._cache.targetScreenOffset.equals(this.targetScreenOffset));
-    }
-    /**
-     * Attached controls to the current camera.
-     * @param ignored defines an ignored parameter kept for backward compatibility.
-     * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
-     * @param useCtrlForPanning  Defines whether ctrl is used for panning within the controls
-     * @param panningMouseButton Defines whether panning is allowed through mouse click button
-     */
-    attachControl(ignored, noPreventDefault, useCtrlForPanning = true, panningMouseButton = 2) {
-        // eslint-disable-next-line prefer-rest-params
-        const args = arguments;
-        noPreventDefault = Tools.BackCompatCameraNoPreventDefault(args);
-        this._useCtrlForPanning = useCtrlForPanning;
-        this._panningMouseButton = panningMouseButton;
-        // backwards compatibility
-        if (typeof args[0] === "boolean") {
-            if (args.length > 1) {
-                this._useCtrlForPanning = args[1];
-            }
-            if (args.length > 2) {
-                this._panningMouseButton = args[2];
-            }
-        }
-        this.inputs.attachElement(noPreventDefault);
-        this._reset = () => {
-            this.inertialAlphaOffset = 0;
-            this.inertialBetaOffset = 0;
-            this.inertialRadiusOffset = 0;
-            this.inertialPanningX = 0;
-            this.inertialPanningY = 0;
-        };
-    }
-    /**
-     * Detach the current controls from the specified dom element.
-     */
-    detachControl() {
-        this.inputs.detachElement();
-        if (this._reset) {
-            this._reset();
-        }
-    }
-    /** @internal */
-    _checkInputs() {
-        //if (async) collision inspection was triggered, don't update the camera's position - until the collision callback was called.
-        if (this._collisionTriggered) {
-            return;
-        }
-        this.inputs.checkInputs();
-        // Inertia
-        if (this.inertialAlphaOffset !== 0 || this.inertialBetaOffset !== 0 || this.inertialRadiusOffset !== 0) {
-            const directionModifier = this.invertRotation ? -1 : 1;
-            let inertialAlphaOffset = this.inertialAlphaOffset;
-            if (this.beta <= 0) {
-                inertialAlphaOffset *= -1;
-            }
-            if (this.getScene().useRightHandedSystem) {
-                inertialAlphaOffset *= -1;
-            }
-            if (this.parent && this.parent._getWorldMatrixDeterminant() < 0) {
-                inertialAlphaOffset *= -1;
-            }
-            this.alpha += inertialAlphaOffset * directionModifier;
-            this.beta += this.inertialBetaOffset * directionModifier;
-            this.radius -= this.inertialRadiusOffset;
-            this.inertialAlphaOffset *= this.inertia;
-            this.inertialBetaOffset *= this.inertia;
-            this.inertialRadiusOffset *= this.inertia;
-            if (Math.abs(this.inertialAlphaOffset) < Epsilon) {
-                this.inertialAlphaOffset = 0;
-            }
-            if (Math.abs(this.inertialBetaOffset) < Epsilon) {
-                this.inertialBetaOffset = 0;
-            }
-            if (Math.abs(this.inertialRadiusOffset) < this.speed * Epsilon) {
-                this.inertialRadiusOffset = 0;
-            }
-        }
-        // Panning inertia
-        if (this.inertialPanningX !== 0 || this.inertialPanningY !== 0) {
-            const localDirection = new Vector3(this.inertialPanningX, this.inertialPanningY, this.inertialPanningY);
-            this._viewMatrix.invertToRef(this._cameraTransformMatrix);
-            localDirection.multiplyInPlace(this.panningAxis);
-            Vector3.TransformNormalToRef(localDirection, this._cameraTransformMatrix, this._transformedDirection);
-            // Eliminate y if mapPanning is enabled
-            if (this.mapPanning || !this.panningAxis.y) {
-                this._transformedDirection.y = 0;
-            }
-            if (!this._targetHost) {
-                if (this.panningDistanceLimit) {
-                    this._transformedDirection.addInPlace(this._target);
-                    const distanceSquared = Vector3.DistanceSquared(this._transformedDirection, this.panningOriginTarget);
-                    if (distanceSquared <= this.panningDistanceLimit * this.panningDistanceLimit) {
-                        this._target.copyFrom(this._transformedDirection);
-                    }
-                }
-                else {
-                    this._target.addInPlace(this._transformedDirection);
-                }
-            }
-            this.inertialPanningX *= this.panningInertia;
-            this.inertialPanningY *= this.panningInertia;
-            if (Math.abs(this.inertialPanningX) < this.speed * Epsilon) {
-                this.inertialPanningX = 0;
-            }
-            if (Math.abs(this.inertialPanningY) < this.speed * Epsilon) {
-                this.inertialPanningY = 0;
-            }
-        }
-        // Limits
-        this._checkLimits();
-        super._checkInputs();
-    }
-    _checkLimits() {
-        if (this.lowerBetaLimit === null || this.lowerBetaLimit === undefined) {
-            if (this.allowUpsideDown && this.beta > Math.PI) {
-                this.beta = this.beta - 2 * Math.PI;
-            }
-        }
-        else {
-            if (this.beta < this.lowerBetaLimit) {
-                this.beta = this.lowerBetaLimit;
-            }
-        }
-        if (this.upperBetaLimit === null || this.upperBetaLimit === undefined) {
-            if (this.allowUpsideDown && this.beta < -Math.PI) {
-                this.beta = this.beta + 2 * Math.PI;
-            }
-        }
-        else {
-            if (this.beta > this.upperBetaLimit) {
-                this.beta = this.upperBetaLimit;
-            }
-        }
-        if (this.lowerAlphaLimit !== null && this.alpha < this.lowerAlphaLimit) {
-            this.alpha = this.lowerAlphaLimit;
-        }
-        if (this.upperAlphaLimit !== null && this.alpha > this.upperAlphaLimit) {
-            this.alpha = this.upperAlphaLimit;
-        }
-        if (this.lowerRadiusLimit !== null && this.radius < this.lowerRadiusLimit) {
-            this.radius = this.lowerRadiusLimit;
-            this.inertialRadiusOffset = 0;
-        }
-        if (this.upperRadiusLimit !== null && this.radius > this.upperRadiusLimit) {
-            this.radius = this.upperRadiusLimit;
-            this.inertialRadiusOffset = 0;
-        }
-    }
-    /**
-     * Rebuilds angles (alpha, beta) and radius from the give position and target
-     */
-    rebuildAnglesAndRadius() {
-        this._position.subtractToRef(this._getTargetPosition(), this._computationVector);
-        // need to rotate to Y up equivalent if up vector not Axis.Y
-        if (this._upVector.x !== 0 || this._upVector.y !== 1.0 || this._upVector.z !== 0) {
-            Vector3.TransformCoordinatesToRef(this._computationVector, this._upToYMatrix, this._computationVector);
-        }
-        this.radius = this._computationVector.length();
-        if (this.radius === 0) {
-            this.radius = 0.0001; // Just to avoid division by zero
-        }
-        // Alpha
-        const previousAlpha = this.alpha;
-        if (this._computationVector.x === 0 && this._computationVector.z === 0) {
-            this.alpha = Math.PI / 2; // avoid division by zero when looking along up axis, and set to acos(0)
-        }
-        else {
-            this.alpha = Math.acos(this._computationVector.x / Math.sqrt(Math.pow(this._computationVector.x, 2) + Math.pow(this._computationVector.z, 2)));
-        }
-        if (this._computationVector.z < 0) {
-            this.alpha = 2 * Math.PI - this.alpha;
-        }
-        // Calculate the number of revolutions between the new and old alpha values.
-        const alphaCorrectionTurns = Math.round((previousAlpha - this.alpha) / (2.0 * Math.PI));
-        // Adjust alpha so that its numerical representation is the closest one to the old value.
-        this.alpha += alphaCorrectionTurns * 2.0 * Math.PI;
-        // Beta
-        this.beta = Math.acos(this._computationVector.y / this.radius);
-        this._checkLimits();
-    }
-    /**
-     * Use a position to define the current camera related information like alpha, beta and radius
-     * @param position Defines the position to set the camera at
-     */
-    setPosition(position) {
-        if (this._position.equals(position)) {
-            return;
-        }
-        this._position.copyFrom(position);
-        this.rebuildAnglesAndRadius();
-    }
-    /**
-     * Defines the target the camera should look at.
-     * This will automatically adapt alpha beta and radius to fit within the new target.
-     * Please note that setting a target as a mesh will disable panning.
-     * @param target Defines the new target as a Vector or a mesh
-     * @param toBoundingCenter In case of a mesh target, defines whether to target the mesh position or its bounding information center
-     * @param allowSamePosition If false, prevents reapplying the new computed position if it is identical to the current one (optim)
-     * @param cloneAlphaBetaRadius If true, replicate the current setup (alpha, beta, radius) on the new target
-     */
-    setTarget(target, toBoundingCenter = false, allowSamePosition = false, cloneAlphaBetaRadius = false) {
-        var _a;
-        cloneAlphaBetaRadius = (_a = this.overrideCloneAlphaBetaRadius) !== null && _a !== void 0 ? _a : cloneAlphaBetaRadius;
-        if (target.getBoundingInfo) {
-            if (toBoundingCenter) {
-                this._targetBoundingCenter = target.getBoundingInfo().boundingBox.centerWorld.clone();
-            }
-            else {
-                this._targetBoundingCenter = null;
-            }
-            target.computeWorldMatrix();
-            this._targetHost = target;
-            this._target = this._getTargetPosition();
-            this.onMeshTargetChangedObservable.notifyObservers(this._targetHost);
-        }
-        else {
-            const newTarget = target;
-            const currentTarget = this._getTargetPosition();
-            if (currentTarget && !allowSamePosition && currentTarget.equals(newTarget)) {
-                return;
-            }
-            this._targetHost = null;
-            this._target = newTarget;
-            this._targetBoundingCenter = null;
-            this.onMeshTargetChangedObservable.notifyObservers(null);
-        }
-        if (!cloneAlphaBetaRadius) {
-            this.rebuildAnglesAndRadius();
-        }
-    }
-    /** @internal */
-    _getViewMatrix() {
-        // Compute
-        const cosa = Math.cos(this.alpha);
-        const sina = Math.sin(this.alpha);
-        const cosb = Math.cos(this.beta);
-        let sinb = Math.sin(this.beta);
-        if (sinb === 0) {
-            sinb = 0.0001;
-        }
-        if (this.radius === 0) {
-            this.radius = 0.0001; // Just to avoid division by zero
-        }
-        const target = this._getTargetPosition();
-        this._computationVector.copyFromFloats(this.radius * cosa * sinb, this.radius * cosb, this.radius * sina * sinb);
-        // Rotate according to up vector
-        if (this._upVector.x !== 0 || this._upVector.y !== 1.0 || this._upVector.z !== 0) {
-            Vector3.TransformCoordinatesToRef(this._computationVector, this._yToUpMatrix, this._computationVector);
-        }
-        target.addToRef(this._computationVector, this._newPosition);
-        if (this.getScene().collisionsEnabled && this.checkCollisions) {
-            const coordinator = this.getScene().collisionCoordinator;
-            if (!this._collider) {
-                this._collider = coordinator.createCollider();
-            }
-            this._collider._radius = this.collisionRadius;
-            this._newPosition.subtractToRef(this._position, this._collisionVelocity);
-            this._collisionTriggered = true;
-            coordinator.getNewPosition(this._position, this._collisionVelocity, this._collider, 3, null, this._onCollisionPositionChange, this.uniqueId);
-        }
-        else {
-            this._position.copyFrom(this._newPosition);
-            let up = this.upVector;
-            if (this.allowUpsideDown && sinb < 0) {
-                up = up.negate();
-            }
-            this._computeViewMatrix(this._position, target, up);
-            this._viewMatrix.addAtIndex(12, this.targetScreenOffset.x);
-            this._viewMatrix.addAtIndex(13, this.targetScreenOffset.y);
-        }
-        this._currentTarget = target;
-        return this._viewMatrix;
-    }
-    /**
-     * Zooms on a mesh to be at the min distance where we could see it fully in the current viewport.
-     * @param meshes Defines the mesh to zoom on
-     * @param doNotUpdateMaxZ Defines whether or not maxZ should be updated whilst zooming on the mesh (this can happen if the mesh is big and the maxradius pretty small for instance)
-     */
-    zoomOn(meshes, doNotUpdateMaxZ = false) {
-        meshes = meshes || this.getScene().meshes;
-        const minMaxVector = Mesh.MinMax(meshes);
-        const distance = Vector3.Distance(minMaxVector.min, minMaxVector.max);
-        this.radius = distance * this.zoomOnFactor;
-        this.focusOn({ min: minMaxVector.min, max: minMaxVector.max, distance: distance }, doNotUpdateMaxZ);
-    }
-    /**
-     * Focus on a mesh or a bounding box. This adapts the target and maxRadius if necessary but does not update the current radius.
-     * The target will be changed but the radius
-     * @param meshesOrMinMaxVectorAndDistance Defines the mesh or bounding info to focus on
-     * @param doNotUpdateMaxZ Defines whether or not maxZ should be updated whilst zooming on the mesh (this can happen if the mesh is big and the maxradius pretty small for instance)
-     */
-    focusOn(meshesOrMinMaxVectorAndDistance, doNotUpdateMaxZ = false) {
-        let meshesOrMinMaxVector;
-        let distance;
-        if (meshesOrMinMaxVectorAndDistance.min === undefined) {
-            // meshes
-            const meshes = meshesOrMinMaxVectorAndDistance || this.getScene().meshes;
-            meshesOrMinMaxVector = Mesh.MinMax(meshes);
-            distance = Vector3.Distance(meshesOrMinMaxVector.min, meshesOrMinMaxVector.max);
-        }
-        else {
-            //minMaxVector and distance
-            const minMaxVectorAndDistance = meshesOrMinMaxVectorAndDistance;
-            meshesOrMinMaxVector = minMaxVectorAndDistance;
-            distance = minMaxVectorAndDistance.distance;
-        }
-        this._target = Mesh.Center(meshesOrMinMaxVector);
-        if (!doNotUpdateMaxZ) {
-            this.maxZ = distance * 2;
-        }
-    }
-    /**
-     * @override
-     * Override Camera.createRigCamera
-     */
-    createRigCamera(name, cameraIndex) {
-        let alphaShift = 0;
-        switch (this.cameraRigMode) {
-            case Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH:
-            case Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL:
-            case Camera.RIG_MODE_STEREOSCOPIC_OVERUNDER:
-            case Camera.RIG_MODE_STEREOSCOPIC_INTERLACED:
-            case Camera.RIG_MODE_VR:
-                alphaShift = this._cameraRigParams.stereoHalfAngle * (cameraIndex === 0 ? 1 : -1);
-                break;
-            case Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_CROSSEYED:
-                alphaShift = this._cameraRigParams.stereoHalfAngle * (cameraIndex === 0 ? -1 : 1);
-                break;
-        }
-        const rigCam = new ArcRotateCamera(name, this.alpha + alphaShift, this.beta, this.radius, this._target, this.getScene());
-        rigCam._cameraRigParams = {};
-        rigCam.isRigCamera = true;
-        rigCam.rigParent = this;
-        rigCam.upVector = this.upVector;
-        rigCam.mode = this.mode;
-        rigCam.orthoLeft = this.orthoLeft;
-        rigCam.orthoRight = this.orthoRight;
-        rigCam.orthoBottom = this.orthoBottom;
-        rigCam.orthoTop = this.orthoTop;
-        return rigCam;
-    }
-    /**
-     * @internal
-     * @override
-     * Override Camera._updateRigCameras
-     */
-    _updateRigCameras() {
-        const camLeft = this._rigCameras[0];
-        const camRight = this._rigCameras[1];
-        camLeft.beta = camRight.beta = this.beta;
-        switch (this.cameraRigMode) {
-            case Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH:
-            case Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL:
-            case Camera.RIG_MODE_STEREOSCOPIC_OVERUNDER:
-            case Camera.RIG_MODE_STEREOSCOPIC_INTERLACED:
-            case Camera.RIG_MODE_VR:
-                camLeft.alpha = this.alpha - this._cameraRigParams.stereoHalfAngle;
-                camRight.alpha = this.alpha + this._cameraRigParams.stereoHalfAngle;
-                break;
-            case Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_CROSSEYED:
-                camLeft.alpha = this.alpha + this._cameraRigParams.stereoHalfAngle;
-                camRight.alpha = this.alpha - this._cameraRigParams.stereoHalfAngle;
-                break;
-        }
-        super._updateRigCameras();
-    }
-    /**
-     * Destroy the camera and release the current resources hold by it.
-     */
-    dispose() {
-        this.inputs.clear();
-        super.dispose();
-    }
-    /**
-     * Gets the current object class name.
-     * @returns the class name
-     */
-    getClassName() {
-        return "ArcRotateCamera";
-    }
-}
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "alpha", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "beta", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "radius", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "overrideCloneAlphaBetaRadius", void 0);
-__decorate([
-    serializeAsVector3("target")
-], ArcRotateCamera.prototype, "_target", void 0);
-__decorate([
-    serializeAsMeshReference("targetHost")
-], ArcRotateCamera.prototype, "_targetHost", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "inertialAlphaOffset", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "inertialBetaOffset", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "inertialRadiusOffset", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "lowerAlphaLimit", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "upperAlphaLimit", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "lowerBetaLimit", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "upperBetaLimit", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "lowerRadiusLimit", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "upperRadiusLimit", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "inertialPanningX", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "inertialPanningY", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "pinchToPanMaxDistance", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "panningDistanceLimit", void 0);
-__decorate([
-    serializeAsVector3()
-], ArcRotateCamera.prototype, "panningOriginTarget", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "panningInertia", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "zoomToMouseLocation", null);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "zoomOnFactor", void 0);
-__decorate([
-    serializeAsVector2()
-], ArcRotateCamera.prototype, "targetScreenOffset", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "allowUpsideDown", void 0);
-__decorate([
-    serialize()
-], ArcRotateCamera.prototype, "useInputToRestoreState", void 0);
-
-/**
- * A slightly extended version of the ArcRotateCamera.
- * Configures the camera in a way that best suites product visualization.
- * Also provides some convenience functions for interacting with the camera at runtime.
- */
-class ProductCamera extends ArcRotateCamera {
-    constructor(name, alpha, beta, radius, target, scene, configuration, setActiveOnSceneIfNoneActive) {
-        super(name, alpha, beta, radius, target, scene, setActiveOnSceneIfNoneActive);
-        /**
-         * Stores the current executed target point of the camera. If the camera target changes
-         * via panning we can notify ui about the fact to help users reset the camera.
-         */
-        this.lastFocus = new Vector3(0, 0, 0);
-        this.panDenominator = 1;
-        // We set some sensible defaults for camera behavior. Some of
-        // these defaults are dependant on calculated camera parameters like radius
-        // which is why we need to ensure that these values are computing straight after the framing behavior
-        // has run so our calculations are correctly computed based on scene scale.
-        this.minZ = 0.01;
-        this.setRadius(this.radius);
-        this.enableFramingBehavior();
-        this.wheelDeltaPercentage = 0.01;
-        this.pinchDeltaPercentage = 0.005;
-        this.useNaturalPinchZoom = true;
-        // glTF assets use a +Z forward convention while the default camera faces +Z.
-        // Rotate the camera to look at the front of the asset by default unless configured not to.
-        if (configuration.camera.autoOrientation) {
-            this.alpha += Math.PI;
-        }
-        // When configuration is available we can go through the camera specific
-        // fields and apply them.
-        if (configuration) {
-            if (configuration.camera.limits.min.beta) {
-                this.lowerBetaLimit = configuration.camera.limits.min.beta;
-            }
-            if (configuration.camera.limits.max.beta) {
-                this.upperBetaLimit = configuration.camera.limits.max.beta;
-            }
-            if (configuration.camera.limits.min.alpha) {
-                this.lowerAlphaLimit = configuration.camera.limits.min.alpha;
-            }
-            if (configuration.camera.limits.max.alpha) {
-                this.upperAlphaLimit = configuration.camera.limits.max.alpha;
-            }
-            if (configuration.camera.limits.min.radius) {
-                this.lowerRadiusLimit = configuration.camera.limits.min.radius;
-            }
-            if (configuration.camera.limits.max.radius) {
-                this.upperRadiusLimit = configuration.camera.limits.max.radius;
-            }
-            configuration.camera.autoRotation.enabled &&
-                this.enableAutoRotationBehavior(configuration.camera.autoRotation.idleTimeMs);
-        }
-    }
-    /**
-     * Returns the framing behavior of this camera.
-     */
-    getFramingBehavior() {
-        return this.getBehaviorByName('Framing');
-    }
-    /**
-     * Returns the auto rotation behavior of this camera, this may
-     * not always be available.
-     */
-    getAutoRotationBehavior() {
-        const autoRotate = this.getBehaviorByName('AutoRotation');
-        if (autoRotate) {
-            return autoRotate;
-        }
-        else {
-            return undefined;
-        }
-    }
-    /**
-     * Activates framing on this camera causing the camera to focus on
-     * the scene and bound itself in a sensible fashion to the scene content.
-     */
-    enableFramingBehavior() {
-        this.useFramingBehavior = true;
-        const framingBehavior = this.getFramingBehavior();
-        framingBehavior.attach(this);
-        framingBehavior.framingTime = 0;
-        framingBehavior.elevationReturnTime = -1;
-        framingBehavior.zoomStopsAnimation = false;
-        this.lowerRadiusLimit = null;
-        // Set the target bounding box for the camera
-        const worldExtends = calculateWorldExtends(this._scene);
-        framingBehavior.zoomOnBoundingInfo(worldExtends.min, worldExtends.max);
-        // Calculate a sensible default for wheel zoom speed based on newly calculated radius.
-        this.wheelPrecision = 100 / this.radius;
-        // If we have no lower radius at this point we must fall back to a default
-        // to prevent the user zooming through the model...
-        if (this.lowerRadiusLimit === null) {
-            this.lowerRadiusLimit = 0.1;
-        }
-        this.lastFocus.copyFrom(this.target);
-        return framingBehavior;
-    }
-    /**
-     * Animates the camera back to the initial target when it has drifted to another position.
-     * @param onAnimationComplete A callback when the camera has finished animating.
-     * @param time The time in milliseconds the animation should take.
-     */
-    rerunFramingBehavior(onAnimationComplete, time) {
-        const framingBehavior = this.getFramingBehavior();
-        framingBehavior.framingTime = time || 800;
-        const handleAnimationComplete = () => {
-            onAnimationComplete && onAnimationComplete();
-        };
-        const worldExtends = calculateWorldExtends(this._scene);
-        const worldSize = worldExtends.max.subtract(worldExtends.min);
-        const worldCenter = worldExtends.min.add(worldSize.scale(0.5));
-        this.setRadius(worldSize.length() * 1.5);
-        // Calculate a sensible default for wheel zoom speed based on newly calculated radius.
-        this.wheelPrecision = 100 / this.radius;
-        // Attach an observer to manage dynamic recalculation of pan speed based on zoom. This will
-        // allow us to keep pan speed consistent regardless of zoom level.
-        this.panningInertia = 0;
-        this.panningOriginTarget.copyFrom(worldCenter);
-        this.panDenominator = worldSize.length();
-        framingBehavior.zoomOnBoundingInfo(worldExtends.min, worldExtends.max, undefined, handleAnimationComplete);
-        framingBehavior.framingTime = 0;
-    }
-    /**
-     * Activates the auto rotation behavior causing the camera to rotate slowly around
-     * it's target.
-     * @param idleTime The number of milliseconds before the camera starts rotating after the user last interacted.
-     */
-    enableAutoRotationBehavior(idleTime = 5000) {
-        this.useAutoRotationBehavior = true;
-        const autoRotation = this.getAutoRotationBehavior();
-        if (!autoRotation) {
-            return;
-        }
-        autoRotation.idleRotationWaitTime = idleTime;
-    }
-    /**
-     * Stops the auto rotation functionality immediately.
-     */
-    disableAutoRotationBehavior() {
-        this.useAutoRotationBehavior = false;
-    }
-    setRadius(radius) {
-        this.radius = radius;
-        this.maxZ = this.radius * 1000;
-        this.lowerRadiusLimit = this.radius * 0.01;
-        this.upperRadiusLimit = 1.5 * this.radius;
-        this.wheelPrecision = 100 / this.radius;
-        this.pinchPrecision = 300 / this.radius;
-    }
-    /**
-     * A static function used to instantiate a single product camera instance on a scene. This camera will assume
-     * the active camera role on the scene and any existing active camera will be disposed.
-     * @param scene The scene to attach the camera to.
-     * @param configuration A configuration object to define the cameras limitations.
-     * @param assignActive If true the camera will be assigned as the active camera on the scene.
-     */
-    static create(scene, configuration, assignActive) {
-        // Build camera
-        const worldExtends = calculateWorldExtends(scene);
-        const worldSize = worldExtends.max.subtract(worldExtends.min);
-        const worldCenter = worldExtends.min.add(worldSize.scale(0.5));
-        const camera = new ProductCamera('ProductCamera', -(Math.PI / 2), Math.PI / 2, worldSize.length() * 1.5, worldCenter, scene, configuration);
-        // Attach an observer to manage dynamic recalculation of pan speed based on zoom. This will
-        // allow us to keep pan speed consistent regardless of zoom level.
-        camera.panningInertia = 0;
-        camera.panningOriginTarget.copyFrom(worldCenter);
-        camera.panDenominator = worldSize.length();
-        camera.onAfterCheckInputsObservable.add(() => {
-            // TODO: There's still an unknown factor here. Dividing 1000 results
-            // in a fairly good experience across the board but really tiny/massive models still
-            // are too fast/slow respectively. Camera.radius also seems to be related...
-            camera.panningSensibility = 1000 / camera.panDenominator;
-        });
-        if (assignActive) {
-            scene.activeCamera = camera;
-        }
-        return camera;
-    }
-}
-/**
- * Determines the  bounding box of all content in the scene that should be included in
- * the focus of the product camera.
- */
-function calculateWorldExtends(scene) {
-    // TODO: Move away from depending on mesh name to determine whether or not a mesh should be targeted
-    if (scene.meshes.length === 0) {
-        return {
-            min: new Vector3(-1, -1, -1),
-            max: new Vector3(1, 1, 1),
-        };
-    }
-    const targetMeshes = scene.meshes.filter((mesh) => {
-        return (mesh.name.toLowerCase().endsWith('_t') ||
-            mesh.name.toLowerCase().includes('_t_'));
-    });
-    return scene.getWorldExtends((mesh) => {
-        return (mesh.isVisible &&
-            mesh.isEnabled() &&
-            (targetMeshes.length === 0 || targetMeshes.includes(mesh)));
-    });
-}
-
-export { ArcRotateCamera as A, CameraInputTypes as C, ProductCamera as P, TargetCamera as T, CameraInputsManager as a };