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

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

@@ -0,0 +1,147 @@
+import { Logger as r } from "../Misc/logger.esm.js";
+import { SerializationHelper as h } from "../Misc/decorators.esm.js";
+import { Camera as o } from "./camera.esm.js";
+var n = {};
+class p {
+  /**
+   * Instantiate a new Camera Input Manager.
+   * @param camera Defines the camera the input manager belongs to
+   */
+  constructor(t) {
+    this.attachedToElement = !1, this.attached = {}, this.camera = t, this.checkInputs = () => {
+    };
+  }
+  /**
+   * Add an input method to a camera
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/customizingCameraInputs
+   * @param input Camera input method
+   */
+  add(t) {
+    const e = t.getSimpleName();
+    if (this.attached[e]) {
+      r.Warn("camera input of type " + e + " already exists on camera");
+      return;
+    }
+    this.attached[e] = t, t.camera = this.camera, t.checkInputs && (this.checkInputs = this._addCheckInputs(t.checkInputs.bind(t))), this.attachedToElement && t.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(t) {
+    for (const e in this.attached) {
+      const a = this.attached[e];
+      if (a === t) {
+        a.detachControl(), a.camera = null, delete this.attached[e], 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(t) {
+    for (const e in this.attached) {
+      const a = this.attached[e];
+      a.getClassName() === t && (a.detachControl(), a.camera = null, delete this.attached[e], this.rebuildInputCheck());
+    }
+  }
+  _addCheckInputs(t) {
+    const e = this.checkInputs;
+    return () => {
+      e(), t();
+    };
+  }
+  /**
+   * Attach the input controls to the currently attached dom element to listen the events from.
+   * @param input Defines the input to attach
+   */
+  attachInput(t) {
+    this.attachedToElement && t.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(t = !1) {
+    if (!this.attachedToElement) {
+      t = o.ForceAttachControlToAlwaysPreventDefault ? !1 : t, this.attachedToElement = !0, this.noPreventDefault = t;
+      for (const e in this.attached)
+        this.attached[e].attachControl(t);
+    }
+  }
+  /**
+   * 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(t = !1) {
+    for (const e in this.attached)
+      this.attached[e].detachControl(), t && (this.attached[e].camera = null);
+    this.attachedToElement = !1;
+  }
+  /**
+   * Rebuild the dynamic inputCheck function from the current list of
+   * defined inputs in the manager.
+   */
+  rebuildInputCheck() {
+    this.checkInputs = () => {
+    };
+    for (const t in this.attached) {
+      const e = this.attached[t];
+      e.checkInputs && (this.checkInputs = this._addCheckInputs(e.checkInputs.bind(e)));
+    }
+  }
+  /**
+   * Remove all attached input methods from a camera
+   */
+  clear() {
+    this.attachedToElement && this.detachElement(!0), this.attached = {}, this.attachedToElement = !1, 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(t) {
+    const e = {};
+    for (const a in this.attached) {
+      const s = this.attached[a], c = h.Serialize(s);
+      e[s.getClassName()] = c;
+    }
+    t.inputsmgr = e;
+  }
+  /**
+   * 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(t) {
+    const e = t.inputsmgr;
+    if (e) {
+      this.clear();
+      for (const a in e) {
+        const s = n[a];
+        if (s) {
+          const c = e[a], i = h.Parse(() => new s(), c, null);
+          this.add(i);
+        }
+      }
+    } else
+      for (const a in this.attached) {
+        const s = n[this.attached[a].getClassName()];
+        if (s) {
+          const c = h.Parse(() => new s(), t, null);
+          this.remove(this.attached[a]), this.add(c);
+        }
+      }
+  }
+}
+export {
+  n as CameraInputTypes,
+  p as CameraInputsManager
+};

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

@@ -0,0 +1,236 @@
+import { __decorate as r } from "../tslib.es6.esm.js";
+import { serializeAsVector3 as d, serialize as h } from "../Misc/decorators.esm.js";
+import { Vector3 as i, Vector2 as c } from "../Maths/math.vector.esm.js";
+import { Engine as y } from "../Engines/engine.esm.js";
+import { TargetCamera as p } from "./targetCamera.esm.js";
+import { FreeCameraInputsManager as k } from "./freeCameraInputsManager.esm.js";
+import { Tools as u } from "../Misc/tools.esm.js";
+class a extends p {
+  /**
+   * Gets the input sensibility for a mouse input. (default is 2000.0)
+   * Higher values reduce sensitivity.
+   */
+  get angularSensibility() {
+    const t = this.inputs.attached.mouse;
+    return t ? t.angularSensibility : 0;
+  }
+  /**
+   * Sets the input sensibility for a mouse input. (default is 2000.0)
+   * Higher values reduce sensitivity.
+   */
+  set angularSensibility(t) {
+    const e = this.inputs.attached.mouse;
+    e && (e.angularSensibility = t);
+  }
+  /**
+   * Gets or Set the list of keyboard keys used to control the forward move of the camera.
+   */
+  get keysUp() {
+    const t = this.inputs.attached.keyboard;
+    return t ? t.keysUp : [];
+  }
+  set keysUp(t) {
+    const e = this.inputs.attached.keyboard;
+    e && (e.keysUp = t);
+  }
+  /**
+   * Gets or Set the list of keyboard keys used to control the upward move of the camera.
+   */
+  get keysUpward() {
+    const t = this.inputs.attached.keyboard;
+    return t ? t.keysUpward : [];
+  }
+  set keysUpward(t) {
+    const e = this.inputs.attached.keyboard;
+    e && (e.keysUpward = t);
+  }
+  /**
+   * Gets or Set the list of keyboard keys used to control the backward move of the camera.
+   */
+  get keysDown() {
+    const t = this.inputs.attached.keyboard;
+    return t ? t.keysDown : [];
+  }
+  set keysDown(t) {
+    const e = this.inputs.attached.keyboard;
+    e && (e.keysDown = t);
+  }
+  /**
+   * Gets or Set the list of keyboard keys used to control the downward move of the camera.
+   */
+  get keysDownward() {
+    const t = this.inputs.attached.keyboard;
+    return t ? t.keysDownward : [];
+  }
+  set keysDownward(t) {
+    const e = this.inputs.attached.keyboard;
+    e && (e.keysDownward = t);
+  }
+  /**
+   * Gets or Set the list of keyboard keys used to control the left strafe move of the camera.
+   */
+  get keysLeft() {
+    const t = this.inputs.attached.keyboard;
+    return t ? t.keysLeft : [];
+  }
+  set keysLeft(t) {
+    const e = this.inputs.attached.keyboard;
+    e && (e.keysLeft = t);
+  }
+  /**
+   * Gets or Set the list of keyboard keys used to control the right strafe move of the camera.
+   */
+  get keysRight() {
+    const t = this.inputs.attached.keyboard;
+    return t ? t.keysRight : [];
+  }
+  set keysRight(t) {
+    const e = this.inputs.attached.keyboard;
+    e && (e.keysRight = t);
+  }
+  /**
+   * Gets or Set the list of keyboard keys used to control the left rotation move of the camera.
+   */
+  get keysRotateLeft() {
+    const t = this.inputs.attached.keyboard;
+    return t ? t.keysRotateLeft : [];
+  }
+  set keysRotateLeft(t) {
+    const e = this.inputs.attached.keyboard;
+    e && (e.keysRotateLeft = t);
+  }
+  /**
+   * Gets or Set the list of keyboard keys used to control the right rotation move of the camera.
+   */
+  get keysRotateRight() {
+    const t = this.inputs.attached.keyboard;
+    return t ? t.keysRotateRight : [];
+  }
+  set keysRotateRight(t) {
+    const e = this.inputs.attached.keyboard;
+    e && (e.keysRotateRight = t);
+  }
+  /**
+   * Gets or Set the list of keyboard keys used to control the up rotation move of the camera.
+   */
+  get keysRotateUp() {
+    const t = this.inputs.attached.keyboard;
+    return t ? t.keysRotateUp : [];
+  }
+  set keysRotateUp(t) {
+    const e = this.inputs.attached.keyboard;
+    e && (e.keysRotateUp = t);
+  }
+  /**
+   * Gets or Set the list of keyboard keys used to control the down rotation move of the camera.
+   */
+  get keysRotateDown() {
+    const t = this.inputs.attached.keyboard;
+    return t ? t.keysRotateDown : [];
+  }
+  set keysRotateDown(t) {
+    const e = this.inputs.attached.keyboard;
+    e && (e.keysRotateDown = t);
+  }
+  /**
+   * Instantiates a Free Camera.
+   * This represents a free type of camera. It can be useful in First Person Shooter game for instance.
+   * Please consider using the new UniversalCamera instead as it adds more functionality like touch to this camera.
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/camera_introduction#universal-camera
+   * @param name Define the name of the camera in the scene
+   * @param position Define the start position of the camera in the scene
+   * @param scene Define 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, e, s, o = !0) {
+    super(t, e, s, o), this.ellipsoid = new i(0.5, 1, 0.5), this.ellipsoidOffset = new i(0, 0, 0), this.checkCollisions = !1, this.applyGravity = !1, this._needMoveForGravity = !1, this._oldPosition = i.Zero(), this._diffPosition = i.Zero(), this._newPosition = i.Zero(), this._collisionMask = -1, this._onCollisionPositionChange = (b, l, n = null) => {
+      this._newPosition.copyFrom(l), this._newPosition.subtractToRef(this._oldPosition, this._diffPosition), this._diffPosition.length() > y.CollisionsEpsilon && (this.position.addToRef(this._diffPosition, this._deferredPositionUpdate), this._deferOnly ? this._deferredUpdated = !0 : this.position.copyFrom(this._deferredPositionUpdate), this.onCollide && n && this.onCollide(n));
+    }, this.inputs = new k(this), this.inputs.addKeyboard().addMouse();
+  }
+  /**
+   * 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)
+   */
+  attachControl(t, e) {
+    e = u.BackCompatCameraNoPreventDefault(arguments), this.inputs.attachElement(e);
+  }
+  /**
+   * Detach the current controls from the specified dom element.
+   */
+  detachControl() {
+    this.inputs.detachElement(), this.cameraDirection = new i(0, 0, 0), this.cameraRotation = new c(0, 0);
+  }
+  /**
+   * Define a collision mask to limit the list of object the camera can collide with
+   */
+  get collisionMask() {
+    return this._collisionMask;
+  }
+  set collisionMask(t) {
+    this._collisionMask = isNaN(t) ? -1 : t;
+  }
+  /**
+   * @internal
+   */
+  _collideWithWorld(t) {
+    let e;
+    this.parent ? e = i.TransformCoordinates(this.position, this.parent.getWorldMatrix()) : e = this.position, e.subtractFromFloatsToRef(0, this.ellipsoid.y, 0, this._oldPosition), this._oldPosition.addInPlace(this.ellipsoidOffset);
+    const s = this.getScene().collisionCoordinator;
+    this._collider || (this._collider = s.createCollider()), this._collider._radius = this.ellipsoid, this._collider.collisionMask = this._collisionMask;
+    let o = t;
+    this.applyGravity && (o = t.add(this.getScene().gravity)), s.getNewPosition(this._oldPosition, o, this._collider, 3, null, this._onCollisionPositionChange, this.uniqueId);
+  }
+  /** @internal */
+  _checkInputs() {
+    this._localDirection || (this._localDirection = i.Zero(), this._transformedDirection = i.Zero()), this.inputs.checkInputs(), super._checkInputs();
+  }
+  /**
+   * Enable movement without a user input. This allows gravity to always be applied.
+   */
+  set needMoveForGravity(t) {
+    this._needMoveForGravity = t;
+  }
+  /**
+   * When true, gravity is applied whether there is user input or not.
+   */
+  get needMoveForGravity() {
+    return this._needMoveForGravity;
+  }
+  /** @internal */
+  _decideIfNeedsToMove() {
+    return this._needMoveForGravity || Math.abs(this.cameraDirection.x) > 0 || Math.abs(this.cameraDirection.y) > 0 || Math.abs(this.cameraDirection.z) > 0;
+  }
+  /** @internal */
+  _updatePosition() {
+    this.checkCollisions && this.getScene().collisionsEnabled ? this._collideWithWorld(this.cameraDirection) : super._updatePosition();
+  }
+  /**
+   * 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 "FreeCamera";
+  }
+}
+r([
+  d()
+], a.prototype, "ellipsoid", void 0);
+r([
+  d()
+], a.prototype, "ellipsoidOffset", void 0);
+r([
+  h()
+], a.prototype, "checkCollisions", void 0);
+r([
+  h()
+], a.prototype, "applyGravity", void 0);
+export {
+  a as FreeCamera
+};

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

@@ -0,0 +1,66 @@
+import { CameraInputsManager as t } from "./cameraInputsManager.esm.js";
+import { FreeCameraKeyboardMoveInput as u } from "./Inputs/freeCameraKeyboardMoveInput.esm.js";
+import { FreeCameraMouseInput as s } from "./Inputs/freeCameraMouseInput.esm.js";
+import { FreeCameraMouseWheelInput as r } from "./Inputs/freeCameraMouseWheelInput.esm.js";
+import { FreeCameraTouchInput as o } from "./Inputs/freeCameraTouchInput.esm.js";
+class d extends t {
+  /**
+   * Instantiates a new FreeCameraInputsManager.
+   * @param camera Defines the camera the inputs belong to
+   */
+  constructor(e) {
+    super(e), this._mouseInput = null, this._mouseWheelInput = null;
+  }
+  /**
+   * Add keyboard input support to the input manager.
+   * @returns the current input manager
+   */
+  addKeyboard() {
+    return this.add(new u()), this;
+  }
+  /**
+   * Add mouse input support to the input manager.
+   * @param touchEnabled if the FreeCameraMouseInput should support touch (default: true)
+   * @returns the current input manager
+   */
+  addMouse(e = !0) {
+    return this._mouseInput || (this._mouseInput = new s(e), this.add(this._mouseInput)), this;
+  }
+  /**
+   * Removes the mouse input support from the manager
+   * @returns the current input manager
+   */
+  removeMouse() {
+    return this._mouseInput && this.remove(this._mouseInput), this;
+  }
+  /**
+   * Add mouse wheel input support to the input manager.
+   * @returns the current input manager
+   */
+  addMouseWheel() {
+    return this._mouseWheelInput || (this._mouseWheelInput = new r(), this.add(this._mouseWheelInput)), this;
+  }
+  /**
+   * Removes the mouse wheel input support from the manager
+   * @returns the current input manager
+   */
+  removeMouseWheel() {
+    return this._mouseWheelInput && this.remove(this._mouseWheelInput), this;
+  }
+  /**
+   * Add touch input support to the input manager.
+   * @returns the current input manager
+   */
+  addTouch() {
+    return this.add(new o()), this;
+  }
+  /**
+   * Remove all attached input methods from a camera
+   */
+  clear() {
+    super.clear(), this._mouseInput = null;
+  }
+}
+export {
+  d as FreeCameraInputsManager
+};

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

@@ -0,0 +1,214 @@
+import { __decorate as _ } from "../tslib.es6.esm.js";
+import { serializeAsVector3 as m, serialize as f, serializeAsMeshReference as p } from "../Misc/decorators.esm.js";
+import { Camera as n } from "./camera.esm.js";
+import { Matrix as s, Vector3 as o, Vector2 as R, Quaternion as h, TmpVectors as d } from "../Maths/math.vector.esm.js";
+import { Epsilon as c } from "../Maths/math.constants.esm.js";
+import { Axis as l } from "../Maths/math.axis.esm.js";
+class a extends n {
+  /**
+   * 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(t, i, e, r = !0) {
+    super(t, i, e, r), this._tmpUpVector = o.Zero(), this._tmpTargetVector = o.Zero(), this.cameraDirection = new o(0, 0, 0), this.cameraRotation = new R(0, 0), this.ignoreParentScaling = !1, this.updateUpVectorFromRotation = !1, this._tmpQuaternion = new h(), this.rotation = new o(0, 0, 0), this.speed = 2, this.noRotationConstraint = !1, this.invertRotation = !1, this.inverseRotationSpeed = 0.2, this.lockedTarget = null, this._currentTarget = o.Zero(), this._initialFocalDistance = 1, this._viewMatrix = s.Zero(), this._camMatrix = s.Zero(), this._cameraTransformMatrix = s.Zero(), this._cameraRotationMatrix = s.Zero(), this._referencePoint = new o(0, 0, 1), this._transformedReferencePoint = o.Zero(), this._deferredPositionUpdate = new o(), this._deferredRotationQuaternionUpdate = new h(), this._deferredRotationUpdate = new o(), this._deferredUpdated = !1, this._deferOnly = !1, this._defaultUp = o.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(t) {
+    this.getWorldMatrix();
+    const i = this.getTarget().subtract(this.position);
+    return i.normalize(), i.scaleInPlace(t), this.globalPosition.add(i);
+  }
+  /** @internal */
+  _getLockedTargetPosition() {
+    if (!this.lockedTarget)
+      return null;
+    if (this.lockedTarget.absolutePosition) {
+      const t = this.lockedTarget;
+      t.computeWorldMatrix().getTranslationToRef(t.absolutePosition);
+    }
+    return this.lockedTarget.absolutePosition || this.lockedTarget;
+  }
+  /**
+   * Store current camera state of the camera (fov, position, rotation, etc..)
+   * @returns the camera
+   */
+  storeState() {
+    return this._storedPosition = this.position.clone(), this._storedRotation = this.rotation.clone(), this.rotationQuaternion && (this._storedRotationQuaternion = this.rotationQuaternion.clone()), super.storeState();
+  }
+  /**
+   * Restored camera state. You must call storeState() first
+   * @returns whether it was successful or not
+   * @internal
+   */
+  _restoreStateValues() {
+    return super._restoreStateValues() ? (this.position = this._storedPosition.clone(), this.rotation = this._storedRotation.clone(), this.rotationQuaternion && (this.rotationQuaternion = this._storedRotationQuaternion.clone()), this.cameraDirection.copyFromFloats(0, 0, 0), this.cameraRotation.copyFromFloats(0, 0), !0) : !1;
+  }
+  /** @internal */
+  _initCache() {
+    super._initCache(), this._cache.lockedTarget = new o(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE), this._cache.rotation = new o(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE), this._cache.rotationQuaternion = new h(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
+  }
+  /**
+   * @internal
+   */
+  _updateCache(t) {
+    t || super._updateCache();
+    const i = this._getLockedTargetPosition();
+    i ? this._cache.lockedTarget ? this._cache.lockedTarget.copyFrom(i) : this._cache.lockedTarget = i.clone() : this._cache.lockedTarget = null, this._cache.rotation.copyFrom(this.rotation), this.rotationQuaternion && this._cache.rotationQuaternion.copyFrom(this.rotationQuaternion);
+  }
+  // Synchronized
+  /** @internal */
+  _isSynchronizedViewMatrix() {
+    if (!super._isSynchronizedViewMatrix())
+      return !1;
+    const t = this._getLockedTargetPosition();
+    return (this._cache.lockedTarget ? this._cache.lockedTarget.equals(t) : !t) && (this.rotationQuaternion ? this.rotationQuaternion.equals(this._cache.rotationQuaternion) : this._cache.rotation.equals(this.rotation));
+  }
+  // Methods
+  /** @internal */
+  _computeLocalCameraSpeed() {
+    const t = this.getEngine();
+    return this.speed * Math.sqrt(t.getDeltaTime() / (t.getFps() * 100));
+  }
+  // Target
+  /**
+   * Defines the target the camera should look at.
+   * @param target Defines the new target as a Vector
+   */
+  setTarget(t) {
+    this.upVector.normalize(), this._initialFocalDistance = t.subtract(this.position).length(), this.position.z === t.z && (this.position.z += c), this._referencePoint.normalize().scaleInPlace(this._initialFocalDistance), s.LookAtLHToRef(this.position, t, this._defaultUp, this._camMatrix), this._camMatrix.invert(), this.rotation.x = Math.atan(this._camMatrix.m[6] / this._camMatrix.m[10]);
+    const i = t.subtract(this.position);
+    i.x >= 0 ? this.rotation.y = -Math.atan(i.z / i.x) + Math.PI / 2 : this.rotation.y = -Math.atan(i.z / i.x) - Math.PI / 2, this.rotation.z = 0, isNaN(this.rotation.x) && (this.rotation.x = 0), isNaN(this.rotation.y) && (this.rotation.y = 0), isNaN(this.rotation.z) && (this.rotation.z = 0), this.rotationQuaternion && h.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(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._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(d.Matrix[0]), o.TransformNormalToRef(this.cameraDirection, d.Matrix[0], d.Vector3[0]), this._deferredPositionUpdate.addInPlace(d.Vector3[0]), this._deferOnly ? this._deferredUpdated = !0 : this.position.copyFrom(this._deferredPositionUpdate);
+      return;
+    }
+    this._deferredPositionUpdate.addInPlace(this.cameraDirection), this._deferOnly ? this._deferredUpdated = !0 : this.position.copyFrom(this._deferredPositionUpdate);
+  }
+  /** @internal */
+  _checkInputs() {
+    const t = this.invertRotation ? -this.inverseRotationSpeed : 1, i = this._decideIfNeedsToMove(), e = this.cameraRotation.x || this.cameraRotation.y;
+    this._deferredUpdated = !1, this._deferredRotationUpdate.copyFrom(this.rotation), this._deferredPositionUpdate.copyFrom(this.position), this.rotationQuaternion && this._deferredRotationQuaternionUpdate.copyFrom(this.rotationQuaternion), i && this._updatePosition(), e && (this.rotationQuaternion && this.rotationQuaternion.toEulerAnglesToRef(this._deferredRotationUpdate), this._deferredRotationUpdate.x += this.cameraRotation.x * t, this._deferredRotationUpdate.y += this.cameraRotation.y * t, this.noRotationConstraint || (this._deferredRotationUpdate.x > 1.570796 && (this._deferredRotationUpdate.x = 1.570796), this._deferredRotationUpdate.x < -1.570796 && (this._deferredRotationUpdate.x = -1.570796)), this._deferOnly ? this._deferredUpdated = !0 : this.rotation.copyFrom(this._deferredRotationUpdate), this.rotationQuaternion && this._deferredRotationUpdate.lengthSquared() && (h.RotationYawPitchRollToRef(this._deferredRotationUpdate.y, this._deferredRotationUpdate.x, this._deferredRotationUpdate.z, this._deferredRotationQuaternionUpdate), this._deferOnly ? this._deferredUpdated = !0 : this.rotationQuaternion.copyFrom(this._deferredRotationQuaternionUpdate))), i && (Math.abs(this.cameraDirection.x) < this.speed * c && (this.cameraDirection.x = 0), Math.abs(this.cameraDirection.y) < this.speed * c && (this.cameraDirection.y = 0), Math.abs(this.cameraDirection.z) < this.speed * c && (this.cameraDirection.z = 0), this.cameraDirection.scaleInPlace(this.inertia)), e && (Math.abs(this.cameraRotation.x) < this.speed * c && (this.cameraRotation.x = 0), Math.abs(this.cameraRotation.y) < this.speed * c && (this.cameraRotation.y = 0), this.cameraRotation.scaleInPlace(this.inertia)), super._checkInputs();
+  }
+  _updateCameraRotationMatrix() {
+    this.rotationQuaternion ? this.rotationQuaternion.toRotationMatrix(this._cameraRotationMatrix) : s.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() {
+    return o.TransformNormalToRef(this._defaultUp, this._cameraRotationMatrix, this.upVector), this;
+  }
+  /** @internal */
+  _getViewMatrix() {
+    return this.lockedTarget && this.setTarget(this._getLockedTargetPosition()), this._updateCameraRotationMatrix(), this.rotationQuaternion && this._cachedQuaternionRotationZ != this.rotationQuaternion.z ? (this._rotateUpVectorWithCameraRotationMatrix(), this._cachedQuaternionRotationZ = this.rotationQuaternion.z) : this._cachedRotationZ !== this.rotation.z && (this._rotateUpVectorWithCameraRotationMatrix(), this._cachedRotationZ = this.rotation.z), o.TransformCoordinatesToRef(this._referencePoint, this._cameraRotationMatrix, this._transformedReferencePoint), this.position.addToRef(this._transformedReferencePoint, this._currentTarget), this.updateUpVectorFromRotation && (this.rotationQuaternion ? l.Y.rotateByQuaternionToRef(this.rotationQuaternion, this.upVector) : (h.FromEulerVectorToRef(this.rotation, this._tmpQuaternion), l.Y.rotateByQuaternionToRef(this._tmpQuaternion, this.upVector))), this._computeViewMatrix(this.position, this._currentTarget, this.upVector), this._viewMatrix;
+  }
+  _computeViewMatrix(t, i, e) {
+    if (this.ignoreParentScaling) {
+      if (this.parent) {
+        const r = this.parent.getWorldMatrix();
+        o.TransformCoordinatesToRef(t, r, this._globalPosition), o.TransformCoordinatesToRef(i, r, this._tmpTargetVector), o.TransformNormalToRef(e, r, this._tmpUpVector), this._markSyncedWithParent();
+      } else
+        this._globalPosition.copyFrom(t), this._tmpTargetVector.copyFrom(i), this._tmpUpVector.copyFrom(e);
+      this.getScene().useRightHandedSystem ? s.LookAtRHToRef(this._globalPosition, this._tmpTargetVector, this._tmpUpVector, this._viewMatrix) : s.LookAtLHToRef(this._globalPosition, this._tmpTargetVector, this._tmpUpVector, this._viewMatrix);
+      return;
+    }
+    if (this.getScene().useRightHandedSystem ? s.LookAtRHToRef(t, i, e, this._viewMatrix) : s.LookAtLHToRef(t, i, e, this._viewMatrix), this.parent) {
+      const r = this.parent.getWorldMatrix();
+      this._viewMatrix.invert(), this._viewMatrix.multiplyToRef(r, this._viewMatrix), this._viewMatrix.getTranslationToRef(this._globalPosition), this._viewMatrix.invert(), this._markSyncedWithParent();
+    } else
+      this._globalPosition.copyFrom(t);
+  }
+  /**
+   * @internal
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  createRigCamera(t, i) {
+    if (this.cameraRigMode !== n.RIG_MODE_NONE) {
+      const e = new a(t, this.position.clone(), this.getScene());
+      return e.isRigCamera = !0, e.rigParent = this, (this.cameraRigMode === n.RIG_MODE_VR || this.cameraRigMode === n.RIG_MODE_WEBVR) && (this.rotationQuaternion || (this.rotationQuaternion = new h()), e._cameraRigParams = {}, e.rotationQuaternion = new h()), e.mode = this.mode, e.orthoLeft = this.orthoLeft, e.orthoRight = this.orthoRight, e.orthoTop = this.orthoTop, e.orthoBottom = this.orthoBottom, e;
+    }
+    return null;
+  }
+  /**
+   * @internal
+   */
+  _updateRigCameras() {
+    const t = this._rigCameras[0], i = this._rigCameras[1];
+    switch (this.computeWorldMatrix(), this.cameraRigMode) {
+      case n.RIG_MODE_STEREOSCOPIC_ANAGLYPH:
+      case n.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL:
+      case n.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_CROSSEYED:
+      case n.RIG_MODE_STEREOSCOPIC_OVERUNDER:
+      case n.RIG_MODE_STEREOSCOPIC_INTERLACED: {
+        const e = this.cameraRigMode === n.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_CROSSEYED ? 1 : -1, r = this.cameraRigMode === n.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_CROSSEYED ? -1 : 1;
+        this._getRigCamPositionAndTarget(this._cameraRigParams.stereoHalfAngle * e, t), this._getRigCamPositionAndTarget(this._cameraRigParams.stereoHalfAngle * r, i);
+        break;
+      }
+      case n.RIG_MODE_VR:
+        t.rotationQuaternion ? (t.rotationQuaternion.copyFrom(this.rotationQuaternion), i.rotationQuaternion.copyFrom(this.rotationQuaternion)) : (t.rotation.copyFrom(this.rotation), i.rotation.copyFrom(this.rotation)), t.position.copyFrom(this.position), i.position.copyFrom(this.position);
+        break;
+    }
+    super._updateRigCameras();
+  }
+  _getRigCamPositionAndTarget(t, i) {
+    this.getTarget().subtractToRef(this.position, a._TargetFocalPoint), a._TargetFocalPoint.normalize().scaleInPlace(this._initialFocalDistance);
+    const r = a._TargetFocalPoint.addInPlace(this.position);
+    s.TranslationToRef(-r.x, -r.y, -r.z, a._TargetTransformMatrix), a._TargetTransformMatrix.multiplyToRef(s.RotationAxis(i.upVector, t), a._RigCamTransformMatrix), s.TranslationToRef(r.x, r.y, r.z, a._TargetTransformMatrix), a._RigCamTransformMatrix.multiplyToRef(a._TargetTransformMatrix, a._RigCamTransformMatrix), o.TransformCoordinatesToRef(this.position, a._RigCamTransformMatrix, i.position), i.setTarget(r);
+  }
+  /**
+   * Gets the current object class name.
+   * @returns the class name
+   */
+  getClassName() {
+    return "TargetCamera";
+  }
+}
+a._RigCamTransformMatrix = new s();
+a._TargetTransformMatrix = new s();
+a._TargetFocalPoint = new o();
+_([
+  m()
+], a.prototype, "rotation", void 0);
+_([
+  f()
+], a.prototype, "speed", void 0);
+_([
+  p("lockedTargetId")
+], a.prototype, "lockedTarget", void 0);
+export {
+  a as TargetCamera
+};

package/dist/node_modules/@babylonjs/core/Collisions/intersectionInfo.esm.js

@@ -0,0 +1,8 @@
+class e {
+  constructor(s, t, i) {
+    this.bu = s, this.bv = t, this.distance = i, this.faceId = 0, this.subMeshId = 0;
+  }
+}
+export {
+  e as IntersectionInfo
+};

package/dist/node_modules/@babylonjs/core/Collisions/meshCollisionData.esm.js

@@ -0,0 +1,9 @@
+import { Vector3 as o } from "../Maths/math.vector.esm.js";
+class l {
+  constructor() {
+    this._checkCollisions = !1, this._collisionMask = -1, this._collisionGroup = -1, this._surroundingMeshes = null, this._collider = null, this._oldPositionForCollisions = new o(0, 0, 0), this._diffPositionForCollisions = new o(0, 0, 0), this._collisionResponse = !0;
+  }
+}
+export {
+  l as _MeshCollisionData
+};