@spiffcommerce/preview 3.6.2-rc.5 → 3.6.2-rc.6

package/dist/node_modules/@babylonjs/core/Cameras/arcRotateCamera.esm.js

@@ -1,589 +0,0 @@
-import { __decorate as a } from "../tslib.es6.esm.js";
-import { serialize as h, serializeAsVector3 as b, serializeAsMeshReference as B, serializeAsVector2 as T } from "../Misc/decorators.esm.js";
-import { Observable as S } from "../Misc/observable.esm.js";
-import { Vector3 as n, Matrix as p, Vector2 as P } from "../Maths/math.vector.esm.js";
-import { Node as A } from "../node.esm.js";
-import { Mesh as _ } from "../Meshes/mesh.esm.js";
-import { AutoRotationBehavior as C } from "../Behaviors/Cameras/autoRotationBehavior.esm.js";
-import { BouncingBehavior as L } from "../Behaviors/Cameras/bouncingBehavior.esm.js";
-import { FramingBehavior as D } from "../Behaviors/Cameras/framingBehavior.esm.js";
-import { Camera as l } from "./camera.esm.js";
-import { TargetCamera as E } from "./targetCamera.esm.js";
-import { ArcRotateCameraInputsManager as I } from "./arcRotateCameraInputsManager.esm.js";
-import { Epsilon as g } from "../Maths/math.constants.esm.js";
-import { Tools as V } from "../Misc/tools.esm.js";
-A.AddNodeConstructor("ArcRotateCamera", (y, t) => () => new s(y, 0, 0, 1, n.Zero(), t));
-class s extends E {
-  /**
-   * Defines the target point of the camera.
-   * The camera looks towards it from the radius distance.
-   */
-  get target() {
-    return this._target;
-  }
-  set target(t) {
-    this.setTarget(t);
-  }
-  /**
-   * 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(t) {
-    t && this.setTarget(t);
-  }
-  /**
-   * 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(t) {
-    this.setPosition(t);
-  }
-  /**
-   * 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(t) {
-    this._upToYMatrix || (this._yToUpMatrix = new p(), this._upToYMatrix = new p(), this._upVector = n.Zero()), t.normalize(), this._upVector.copyFrom(t), 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() {
-    p.RotationAlignToRef(n.UpReadOnly, this._upVector, this._yToUpMatrix), p.RotationAlignToRef(this._upVector, n.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 t = this.inputs.attached.pointers;
-    return t ? t.angularSensibilityX : 0;
-  }
-  set angularSensibilityX(t) {
-    const i = this.inputs.attached.pointers;
-    i && (i.angularSensibilityX = t);
-  }
-  /**
-   * Gets or Set the pointer angular sensibility along the Y axis or how fast is the camera rotating.
-   */
-  get angularSensibilityY() {
-    const t = this.inputs.attached.pointers;
-    return t ? t.angularSensibilityY : 0;
-  }
-  set angularSensibilityY(t) {
-    const i = this.inputs.attached.pointers;
-    i && (i.angularSensibilityY = t);
-  }
-  /**
-   * Gets or Set the pointer pinch precision or how fast is the camera zooming.
-   */
-  get pinchPrecision() {
-    const t = this.inputs.attached.pointers;
-    return t ? t.pinchPrecision : 0;
-  }
-  set pinchPrecision(t) {
-    const i = this.inputs.attached.pointers;
-    i && (i.pinchPrecision = t);
-  }
-  /**
-   * 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 t = this.inputs.attached.pointers;
-    return t ? t.pinchDeltaPercentage : 0;
-  }
-  set pinchDeltaPercentage(t) {
-    const i = this.inputs.attached.pointers;
-    i && (i.pinchDeltaPercentage = t);
-  }
-  /**
-   * 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 t = this.inputs.attached.pointers;
-    return t ? t.useNaturalPinchZoom : !1;
-  }
-  set useNaturalPinchZoom(t) {
-    const i = this.inputs.attached.pointers;
-    i && (i.useNaturalPinchZoom = t);
-  }
-  /**
-   * Gets or Set the pointer panning sensibility or how fast is the camera moving.
-   */
-  get panningSensibility() {
-    const t = this.inputs.attached.pointers;
-    return t ? t.panningSensibility : 0;
-  }
-  set panningSensibility(t) {
-    const i = this.inputs.attached.pointers;
-    i && (i.panningSensibility = t);
-  }
-  /**
-   * Gets or Set the list of keyboard keys used to control beta angle in a positive direction.
-   */
-  get keysUp() {
-    const t = this.inputs.attached.keyboard;
-    return t ? t.keysUp : [];
-  }
-  set keysUp(t) {
-    const i = this.inputs.attached.keyboard;
-    i && (i.keysUp = t);
-  }
-  /**
-   * Gets or Set the list of keyboard keys used to control beta angle in a negative direction.
-   */
-  get keysDown() {
-    const t = this.inputs.attached.keyboard;
-    return t ? t.keysDown : [];
-  }
-  set keysDown(t) {
-    const i = this.inputs.attached.keyboard;
-    i && (i.keysDown = t);
-  }
-  /**
-   * Gets or Set the list of keyboard keys used to control alpha angle in a negative direction.
-   */
-  get keysLeft() {
-    const t = this.inputs.attached.keyboard;
-    return t ? t.keysLeft : [];
-  }
-  set keysLeft(t) {
-    const i = this.inputs.attached.keyboard;
-    i && (i.keysLeft = t);
-  }
-  /**
-   * Gets or Set the list of keyboard keys used to control alpha angle in a positive direction.
-   */
-  get keysRight() {
-    const t = this.inputs.attached.keyboard;
-    return t ? t.keysRight : [];
-  }
-  set keysRight(t) {
-    const i = this.inputs.attached.keyboard;
-    i && (i.keysRight = t);
-  }
-  /**
-   * Gets or Set the mouse wheel precision or how fast is the camera zooming.
-   */
-  get wheelPrecision() {
-    const t = this.inputs.attached.mousewheel;
-    return t ? t.wheelPrecision : 0;
-  }
-  set wheelPrecision(t) {
-    const i = this.inputs.attached.mousewheel;
-    i && (i.wheelPrecision = t);
-  }
-  /**
-   * 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 t = this.inputs.attached.mousewheel;
-    return t ? t.zoomToMouseLocation : !1;
-  }
-  set zoomToMouseLocation(t) {
-    const i = this.inputs.attached.mousewheel;
-    i && (i.zoomToMouseLocation = t);
-  }
-  /**
-   * 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 t = this.inputs.attached.mousewheel;
-    return t ? t.wheelDeltaPercentage : 0;
-  }
-  set wheelDeltaPercentage(t) {
-    const i = this.inputs.attached.mousewheel;
-    i && (i.wheelDeltaPercentage = t);
-  }
-  /**
-   * 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(t) {
-    t !== this.useBouncingBehavior && (t ? (this._bouncingBehavior = new L(), this.addBehavior(this._bouncingBehavior)) : 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(t) {
-    t !== this.useFramingBehavior && (t ? (this._framingBehavior = new D(), this.addBehavior(this._framingBehavior)) : 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(t) {
-    t !== this.useAutoRotationBehavior && (t ? (this._autoRotationBehavior = new C(), this.addBehavior(this._autoRotationBehavior)) : 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(t, i, o, e, r, c, d = !0) {
-    super(t, n.Zero(), c, d), this.inertialAlphaOffset = 0, this.inertialBetaOffset = 0, this.inertialRadiusOffset = 0, this.lowerAlphaLimit = null, this.upperAlphaLimit = null, this.lowerBetaLimit = 0.01, this.upperBetaLimit = Math.PI - 0.01, this.lowerRadiusLimit = null, this.upperRadiusLimit = null, this.inertialPanningX = 0, this.inertialPanningY = 0, this.pinchToPanMaxDistance = 20, this.panningDistanceLimit = null, this.panningOriginTarget = n.Zero(), this.panningInertia = 0.9, this.zoomOnFactor = 1, this.targetScreenOffset = P.Zero(), this.allowUpsideDown = !0, this.useInputToRestoreState = !0, this._viewMatrix = new p(), this.panningAxis = new n(1, 1, 0), this._transformedDirection = new n(), this.mapPanning = !1, this.onMeshTargetChangedObservable = new S(), this.checkCollisions = !1, this.collisionRadius = new n(0.5, 0.5, 0.5), this._previousPosition = n.Zero(), this._collisionVelocity = n.Zero(), this._newPosition = n.Zero(), this._computationVector = n.Zero(), this._onCollisionPositionChange = (x, O, m = null) => {
-      m ? (this.setPosition(O), this.onCollide && this.onCollide(m)) : this._previousPosition.copyFrom(this._position);
-      const w = Math.cos(this.alpha), M = Math.sin(this.alpha), v = Math.cos(this.beta);
-      let f = Math.sin(this.beta);
-      f === 0 && (f = 1e-4);
-      const R = this._getTargetPosition();
-      this._computationVector.copyFromFloats(this.radius * w * f, this.radius * v, this.radius * M * f), R.addToRef(this._computationVector, this._newPosition), this._position.copyFrom(this._newPosition);
-      let u = this.upVector;
-      this.allowUpsideDown && this.beta < 0 && (u = u.clone(), u = u.negate()), this._computeViewMatrix(this._position, R, u), this._viewMatrix.addAtIndex(12, this.targetScreenOffset.x), this._viewMatrix.addAtIndex(13, this.targetScreenOffset.y), this._collisionTriggered = !1;
-    }, this._target = n.Zero(), r && this.setTarget(r), this.alpha = i, this.beta = o, this.radius = e, this.getViewMatrix(), this.inputs = new I(this), this.inputs.addKeyboard().addMouseWheel().addPointers();
-  }
-  // Cache
-  /** @internal */
-  _initCache() {
-    super._initCache(), this._cache._target = new n(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE), this._cache.alpha = void 0, this._cache.beta = void 0, this._cache.radius = void 0, this._cache.targetScreenOffset = P.Zero();
-  }
-  /**
-   * @internal
-   */
-  _updateCache(t) {
-    t || 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 i = this._targetHost.getAbsolutePosition();
-      this._targetBoundingCenter ? i.addToRef(this._targetBoundingCenter, this._target) : this._target.copyFrom(i);
-    }
-    const t = this._getLockedTargetPosition();
-    return t || this._target;
-  }
-  /**
-   * Stores the current state of the camera (alpha, beta, radius and target)
-   * @returns the camera itself
-   */
-  storeState() {
-    return this._storedAlpha = this.alpha, this._storedBeta = this.beta, this._storedRadius = this.radius, this._storedTarget = this._getTargetPosition().clone(), this._storedTargetScreenOffset = this.targetScreenOffset.clone(), super.storeState();
-  }
-  /**
-   * @internal
-   * Restored camera state. You must call storeState() first
-   */
-  _restoreStateValues() {
-    return super._restoreStateValues() ? (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, !0) : !1;
-  }
-  // Synchronized
-  /** @internal */
-  _isSynchronizedViewMatrix() {
-    return super._isSynchronizedViewMatrix() ? 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) : !1;
-  }
-  /**
-   * 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(t, i, o = !0, e = 2) {
-    const r = arguments;
-    i = V.BackCompatCameraNoPreventDefault(r), this._useCtrlForPanning = o, this._panningMouseButton = e, typeof r[0] == "boolean" && (r.length > 1 && (this._useCtrlForPanning = r[1]), r.length > 2 && (this._panningMouseButton = r[2])), this.inputs.attachElement(i), 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(), this._reset && this._reset();
-  }
-  /** @internal */
-  _checkInputs() {
-    if (!this._collisionTriggered) {
-      if (this.inputs.checkInputs(), this.inertialAlphaOffset !== 0 || this.inertialBetaOffset !== 0 || this.inertialRadiusOffset !== 0) {
-        const t = this.invertRotation ? -1 : 1;
-        let i = this.inertialAlphaOffset;
-        this.beta <= 0 && (i *= -1), this.getScene().useRightHandedSystem && (i *= -1), this.parent && this.parent._getWorldMatrixDeterminant() < 0 && (i *= -1), this.alpha += i * t, this.beta += this.inertialBetaOffset * t, this.radius -= this.inertialRadiusOffset, this.inertialAlphaOffset *= this.inertia, this.inertialBetaOffset *= this.inertia, this.inertialRadiusOffset *= this.inertia, Math.abs(this.inertialAlphaOffset) < g && (this.inertialAlphaOffset = 0), Math.abs(this.inertialBetaOffset) < g && (this.inertialBetaOffset = 0), Math.abs(this.inertialRadiusOffset) < this.speed * g && (this.inertialRadiusOffset = 0);
-      }
-      if (this.inertialPanningX !== 0 || this.inertialPanningY !== 0) {
-        const t = new n(this.inertialPanningX, this.inertialPanningY, this.inertialPanningY);
-        this._viewMatrix.invertToRef(this._cameraTransformMatrix), t.multiplyInPlace(this.panningAxis), n.TransformNormalToRef(t, this._cameraTransformMatrix, this._transformedDirection), (this.mapPanning || !this.panningAxis.y) && (this._transformedDirection.y = 0), this._targetHost || (this.panningDistanceLimit ? (this._transformedDirection.addInPlace(this._target), n.DistanceSquared(this._transformedDirection, this.panningOriginTarget) <= this.panningDistanceLimit * this.panningDistanceLimit && this._target.copyFrom(this._transformedDirection)) : this._target.addInPlace(this._transformedDirection)), this.inertialPanningX *= this.panningInertia, this.inertialPanningY *= this.panningInertia, Math.abs(this.inertialPanningX) < this.speed * g && (this.inertialPanningX = 0), Math.abs(this.inertialPanningY) < this.speed * g && (this.inertialPanningY = 0);
-      }
-      this._checkLimits(), super._checkInputs();
-    }
-  }
-  _checkLimits() {
-    this.lowerBetaLimit === null || this.lowerBetaLimit === void 0 ? this.allowUpsideDown && this.beta > Math.PI && (this.beta = this.beta - 2 * Math.PI) : this.beta < this.lowerBetaLimit && (this.beta = this.lowerBetaLimit), this.upperBetaLimit === null || this.upperBetaLimit === void 0 ? this.allowUpsideDown && this.beta < -Math.PI && (this.beta = this.beta + 2 * Math.PI) : this.beta > this.upperBetaLimit && (this.beta = this.upperBetaLimit), this.lowerAlphaLimit !== null && this.alpha < this.lowerAlphaLimit && (this.alpha = this.lowerAlphaLimit), this.upperAlphaLimit !== null && this.alpha > this.upperAlphaLimit && (this.alpha = this.upperAlphaLimit), this.lowerRadiusLimit !== null && this.radius < this.lowerRadiusLimit && (this.radius = this.lowerRadiusLimit, this.inertialRadiusOffset = 0), 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), (this._upVector.x !== 0 || this._upVector.y !== 1 || this._upVector.z !== 0) && n.TransformCoordinatesToRef(this._computationVector, this._upToYMatrix, this._computationVector), this.radius = this._computationVector.length(), this.radius === 0 && (this.radius = 1e-4);
-    const t = this.alpha;
-    this._computationVector.x === 0 && this._computationVector.z === 0 ? this.alpha = Math.PI / 2 : this.alpha = Math.acos(this._computationVector.x / Math.sqrt(Math.pow(this._computationVector.x, 2) + Math.pow(this._computationVector.z, 2))), this._computationVector.z < 0 && (this.alpha = 2 * Math.PI - this.alpha);
-    const i = Math.round((t - this.alpha) / (2 * Math.PI));
-    this.alpha += i * 2 * Math.PI, 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(t) {
-    this._position.equals(t) || (this._position.copyFrom(t), 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(t, i = !1, o = !1, e = !1) {
-    var r;
-    if (e = (r = this.overrideCloneAlphaBetaRadius) !== null && r !== void 0 ? r : e, t.getBoundingInfo)
-      i ? this._targetBoundingCenter = t.getBoundingInfo().boundingBox.centerWorld.clone() : this._targetBoundingCenter = null, t.computeWorldMatrix(), this._targetHost = t, this._target = this._getTargetPosition(), this.onMeshTargetChangedObservable.notifyObservers(this._targetHost);
-    else {
-      const c = t, d = this._getTargetPosition();
-      if (d && !o && d.equals(c))
-        return;
-      this._targetHost = null, this._target = c, this._targetBoundingCenter = null, this.onMeshTargetChangedObservable.notifyObservers(null);
-    }
-    e || this.rebuildAnglesAndRadius();
-  }
-  /** @internal */
-  _getViewMatrix() {
-    const t = Math.cos(this.alpha), i = Math.sin(this.alpha), o = Math.cos(this.beta);
-    let e = Math.sin(this.beta);
-    e === 0 && (e = 1e-4), this.radius === 0 && (this.radius = 1e-4);
-    const r = this._getTargetPosition();
-    if (this._computationVector.copyFromFloats(this.radius * t * e, this.radius * o, this.radius * i * e), (this._upVector.x !== 0 || this._upVector.y !== 1 || this._upVector.z !== 0) && n.TransformCoordinatesToRef(this._computationVector, this._yToUpMatrix, this._computationVector), r.addToRef(this._computationVector, this._newPosition), this.getScene().collisionsEnabled && this.checkCollisions) {
-      const c = this.getScene().collisionCoordinator;
-      this._collider || (this._collider = c.createCollider()), this._collider._radius = this.collisionRadius, this._newPosition.subtractToRef(this._position, this._collisionVelocity), this._collisionTriggered = !0, c.getNewPosition(this._position, this._collisionVelocity, this._collider, 3, null, this._onCollisionPositionChange, this.uniqueId);
-    } else {
-      this._position.copyFrom(this._newPosition);
-      let c = this.upVector;
-      this.allowUpsideDown && e < 0 && (c = c.negate()), this._computeViewMatrix(this._position, r, c), this._viewMatrix.addAtIndex(12, this.targetScreenOffset.x), this._viewMatrix.addAtIndex(13, this.targetScreenOffset.y);
-    }
-    return this._currentTarget = r, 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(t, i = !1) {
-    t = t || this.getScene().meshes;
-    const o = _.MinMax(t), e = n.Distance(o.min, o.max);
-    this.radius = e * this.zoomOnFactor, this.focusOn({ min: o.min, max: o.max, distance: e }, i);
-  }
-  /**
-   * 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(t, i = !1) {
-    let o, e;
-    if (t.min === void 0) {
-      const r = t || this.getScene().meshes;
-      o = _.MinMax(r), e = n.Distance(o.min, o.max);
-    } else {
-      const r = t;
-      o = r, e = r.distance;
-    }
-    this._target = _.Center(o), i || (this.maxZ = e * 2);
-  }
-  /**
-   * @override
-   * Override Camera.createRigCamera
-   */
-  createRigCamera(t, i) {
-    let o = 0;
-    switch (this.cameraRigMode) {
-      case l.RIG_MODE_STEREOSCOPIC_ANAGLYPH:
-      case l.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL:
-      case l.RIG_MODE_STEREOSCOPIC_OVERUNDER:
-      case l.RIG_MODE_STEREOSCOPIC_INTERLACED:
-      case l.RIG_MODE_VR:
-        o = this._cameraRigParams.stereoHalfAngle * (i === 0 ? 1 : -1);
-        break;
-      case l.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_CROSSEYED:
-        o = this._cameraRigParams.stereoHalfAngle * (i === 0 ? -1 : 1);
-        break;
-    }
-    const e = new s(t, this.alpha + o, this.beta, this.radius, this._target, this.getScene());
-    return e._cameraRigParams = {}, e.isRigCamera = !0, e.rigParent = this, e.upVector = this.upVector, e.mode = this.mode, e.orthoLeft = this.orthoLeft, e.orthoRight = this.orthoRight, e.orthoBottom = this.orthoBottom, e.orthoTop = this.orthoTop, e;
-  }
-  /**
-   * @internal
-   * @override
-   * Override Camera._updateRigCameras
-   */
-  _updateRigCameras() {
-    const t = this._rigCameras[0], i = this._rigCameras[1];
-    switch (t.beta = i.beta = this.beta, this.cameraRigMode) {
-      case l.RIG_MODE_STEREOSCOPIC_ANAGLYPH:
-      case l.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL:
-      case l.RIG_MODE_STEREOSCOPIC_OVERUNDER:
-      case l.RIG_MODE_STEREOSCOPIC_INTERLACED:
-      case l.RIG_MODE_VR:
-        t.alpha = this.alpha - this._cameraRigParams.stereoHalfAngle, i.alpha = this.alpha + this._cameraRigParams.stereoHalfAngle;
-        break;
-      case l.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_CROSSEYED:
-        t.alpha = this.alpha + this._cameraRigParams.stereoHalfAngle, i.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";
-  }
-}
-a([
-  h()
-], s.prototype, "alpha", void 0);
-a([
-  h()
-], s.prototype, "beta", void 0);
-a([
-  h()
-], s.prototype, "radius", void 0);
-a([
-  h()
-], s.prototype, "overrideCloneAlphaBetaRadius", void 0);
-a([
-  b("target")
-], s.prototype, "_target", void 0);
-a([
-  B("targetHost")
-], s.prototype, "_targetHost", void 0);
-a([
-  h()
-], s.prototype, "inertialAlphaOffset", void 0);
-a([
-  h()
-], s.prototype, "inertialBetaOffset", void 0);
-a([
-  h()
-], s.prototype, "inertialRadiusOffset", void 0);
-a([
-  h()
-], s.prototype, "lowerAlphaLimit", void 0);
-a([
-  h()
-], s.prototype, "upperAlphaLimit", void 0);
-a([
-  h()
-], s.prototype, "lowerBetaLimit", void 0);
-a([
-  h()
-], s.prototype, "upperBetaLimit", void 0);
-a([
-  h()
-], s.prototype, "lowerRadiusLimit", void 0);
-a([
-  h()
-], s.prototype, "upperRadiusLimit", void 0);
-a([
-  h()
-], s.prototype, "inertialPanningX", void 0);
-a([
-  h()
-], s.prototype, "inertialPanningY", void 0);
-a([
-  h()
-], s.prototype, "pinchToPanMaxDistance", void 0);
-a([
-  h()
-], s.prototype, "panningDistanceLimit", void 0);
-a([
-  b()
-], s.prototype, "panningOriginTarget", void 0);
-a([
-  h()
-], s.prototype, "panningInertia", void 0);
-a([
-  h()
-], s.prototype, "zoomToMouseLocation", null);
-a([
-  h()
-], s.prototype, "zoomOnFactor", void 0);
-a([
-  T()
-], s.prototype, "targetScreenOffset", void 0);
-a([
-  h()
-], s.prototype, "allowUpsideDown", void 0);
-a([
-  h()
-], s.prototype, "useInputToRestoreState", void 0);
-export {
-  s as ArcRotateCamera
-};

package/dist/node_modules/@babylonjs/core/Cameras/arcRotateCameraInputsManager.esm.js

@@ -1,37 +0,0 @@
-import { ArcRotateCameraPointersInput as e } from "./Inputs/arcRotateCameraPointersInput.esm.js";
-import { ArcRotateCameraKeyboardMoveInput as t } from "./Inputs/arcRotateCameraKeyboardMoveInput.esm.js";
-import { ArcRotateCameraMouseWheelInput as a } from "./Inputs/arcRotateCameraMouseWheelInput.esm.js";
-import { CameraInputsManager as o } from "./cameraInputsManager.esm.js";
-class u extends o {
-  /**
-   * Instantiates a new ArcRotateCameraInputsManager.
-   * @param camera Defines the camera the inputs belong to
-   */
-  constructor(r) {
-    super(r);
-  }
-  /**
-   * Add mouse wheel input support to the input manager.
-   * @returns the current input manager
-   */
-  addMouseWheel() {
-    return this.add(new a()), this;
-  }
-  /**
-   * Add pointers input support to the input manager.
-   * @returns the current input manager
-   */
-  addPointers() {
-    return this.add(new e()), this;
-  }
-  /**
-   * Add keyboard input support to the input manager.
-   * @returns the current input manager
-   */
-  addKeyboard() {
-    return this.add(new t()), this;
-  }
-}
-export {
-  u as ArcRotateCameraInputsManager
-};