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

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

@@ -0,0 +1,589 @@
+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

@@ -0,0 +1,37 @@
+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
+};