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

package/dist/node_modules/@babylonjs/core/Cameras/Inputs/BaseCameraPointersInput.esm.js

@@ -0,0 +1,191 @@
+import { __decorate as v } from "../../tslib.es6.esm.js";
+import { serialize as A } from "../../Misc/decorators.esm.js";
+import { Tools as d } from "../../Misc/tools.esm.js";
+import { PointerEventTypes as e } from "../../Events/pointerEvents.esm.js";
+class I {
+  constructor() {
+    this._currentActiveButton = -1, this.buttons = [0, 1, 2];
+  }
+  /**
+   * Attach the input controls to a specific dom element to get the input from.
+   * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
+   */
+  attachControl(i) {
+    i = d.BackCompatCameraNoPreventDefault(arguments);
+    const h = this.camera.getEngine(), p = h.getInputElement();
+    let s = 0, r = null;
+    this._pointA = null, this._pointB = null, this._altKey = !1, this._ctrlKey = !1, this._metaKey = !1, this._shiftKey = !1, this._buttonsPressed = 0, this._pointerInput = (n) => {
+      var a, f;
+      const t = n.event, c = t.pointerType === "touch";
+      if (h.isInVRExclusivePointerMode || n.type !== e.POINTERMOVE && this.buttons.indexOf(t.button) === -1)
+        return;
+      const u = t.target;
+      if (this._altKey = t.altKey, this._ctrlKey = t.ctrlKey, this._metaKey = t.metaKey, this._shiftKey = t.shiftKey, this._buttonsPressed = t.buttons, h.isPointerLock) {
+        const o = t.movementX, l = t.movementY;
+        this.onTouch(null, o, l), this._pointA = null, this._pointB = null;
+      } else {
+        if (n.type !== e.POINTERDOWN && c && ((a = this._pointA) === null || a === void 0 ? void 0 : a.pointerId) !== t.pointerId && ((f = this._pointB) === null || f === void 0 ? void 0 : f.pointerId) !== t.pointerId)
+          return;
+        if (n.type === e.POINTERDOWN && (this._currentActiveButton === -1 || c)) {
+          try {
+            u == null || u.setPointerCapture(t.pointerId);
+          } catch {
+          }
+          if (this._pointA === null)
+            this._pointA = {
+              x: t.clientX,
+              y: t.clientY,
+              pointerId: t.pointerId,
+              type: t.pointerType
+            };
+          else if (this._pointB === null)
+            this._pointB = {
+              x: t.clientX,
+              y: t.clientY,
+              pointerId: t.pointerId,
+              type: t.pointerType
+            };
+          else
+            return;
+          this._currentActiveButton === -1 && !c && (this._currentActiveButton = t.button), this.onButtonDown(t), i || (t.preventDefault(), p && p.focus());
+        } else if (n.type === e.POINTERDOUBLETAP)
+          this.onDoubleTap(t.pointerType);
+        else if (n.type === e.POINTERUP && (this._currentActiveButton === t.button || c)) {
+          try {
+            u == null || u.releasePointerCapture(t.pointerId);
+          } catch {
+          }
+          c || (this._pointB = null), h._badOS ? this._pointA = this._pointB = null : this._pointB && this._pointA && this._pointA.pointerId == t.pointerId ? (this._pointA = this._pointB, this._pointB = null) : this._pointA && this._pointB && this._pointB.pointerId == t.pointerId ? this._pointB = null : this._pointA = this._pointB = null, (s !== 0 || r) && (this.onMultiTouch(
+            this._pointA,
+            this._pointB,
+            s,
+            0,
+            // pinchSquaredDistance
+            r,
+            null
+            // multiTouchPanPosition
+          ), s = 0, r = null), this._currentActiveButton = -1, this.onButtonUp(t), i || t.preventDefault();
+        } else if (n.type === e.POINTERMOVE) {
+          if (i || t.preventDefault(), this._pointA && this._pointB === null) {
+            const o = t.clientX - this._pointA.x, l = t.clientY - this._pointA.y;
+            this.onTouch(this._pointA, o, l), this._pointA.x = t.clientX, this._pointA.y = t.clientY;
+          } else if (this._pointA && this._pointB) {
+            const o = this._pointA.pointerId === t.pointerId ? this._pointA : this._pointB;
+            o.x = t.clientX, o.y = t.clientY;
+            const l = this._pointA.x - this._pointB.x, m = this._pointA.y - this._pointB.y, y = l * l + m * m, B = {
+              x: (this._pointA.x + this._pointB.x) / 2,
+              y: (this._pointA.y + this._pointB.y) / 2,
+              pointerId: t.pointerId,
+              type: n.type
+            };
+            this.onMultiTouch(this._pointA, this._pointB, s, y, r, B), r = B, s = y;
+          }
+        }
+      }
+    }, this._observer = this.camera.getScene()._inputManager._addCameraPointerObserver(this._pointerInput, e.POINTERDOWN | e.POINTERUP | e.POINTERMOVE | e.POINTERDOUBLETAP), this._onLostFocus = () => {
+      this._pointA = this._pointB = null, s = 0, r = null, this.onLostFocus();
+    }, this._contextMenuBind = this.onContextMenu.bind(this), p && p.addEventListener("contextmenu", this._contextMenuBind, !1);
+    const _ = this.camera.getScene().getEngine().getHostWindow();
+    _ && d.RegisterTopRootEvents(_, [{ name: "blur", handler: this._onLostFocus }]);
+  }
+  /**
+   * Detach the current controls from the specified dom element.
+   */
+  detachControl() {
+    if (this._onLostFocus) {
+      const i = this.camera.getScene().getEngine().getHostWindow();
+      i && d.UnregisterTopRootEvents(i, [{ name: "blur", handler: this._onLostFocus }]);
+    }
+    if (this._observer) {
+      if (this.camera.getScene()._inputManager._removeCameraPointerObserver(this._observer), this._observer = null, this._contextMenuBind) {
+        const i = this.camera.getScene().getEngine().getInputElement();
+        i && i.removeEventListener("contextmenu", this._contextMenuBind);
+      }
+      this._onLostFocus = null;
+    }
+    this._altKey = !1, this._ctrlKey = !1, this._metaKey = !1, this._shiftKey = !1, this._buttonsPressed = 0, this._currentActiveButton = -1;
+  }
+  /**
+   * Gets the class name of the current input.
+   * @returns the class name
+   */
+  getClassName() {
+    return "BaseCameraPointersInput";
+  }
+  /**
+   * Get the friendly name associated with the input class.
+   * @returns the input friendly name
+   */
+  getSimpleName() {
+    return "pointers";
+  }
+  /**
+   * Called on pointer POINTERDOUBLETAP event.
+   * Override this method to provide functionality on POINTERDOUBLETAP event.
+   * @param type
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  onDoubleTap(i) {
+  }
+  /**
+   * Called on pointer POINTERMOVE event if only a single touch is active.
+   * Override this method to provide functionality.
+   * @param point
+   * @param offsetX
+   * @param offsetY
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  onTouch(i, h, p) {
+  }
+  /**
+   * Called on pointer POINTERMOVE event if multiple touches are active.
+   * Override this method to provide functionality.
+   * @param _pointA
+   * @param _pointB
+   * @param previousPinchSquaredDistance
+   * @param pinchSquaredDistance
+   * @param previousMultiTouchPanPosition
+   * @param multiTouchPanPosition
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  onMultiTouch(i, h, p, s, r, _) {
+  }
+  /**
+   * Called on JS contextmenu event.
+   * Override this method to provide functionality.
+   * @param evt
+   */
+  onContextMenu(i) {
+    i.preventDefault();
+  }
+  /**
+   * Called each time a new POINTERDOWN event occurs. Ie, for each button
+   * press.
+   * Override this method to provide functionality.
+   * @param evt
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  onButtonDown(i) {
+  }
+  /**
+   * Called each time a new POINTERUP event occurs. Ie, for each button
+   * release.
+   * Override this method to provide functionality.
+   * @param evt
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  onButtonUp(i) {
+  }
+  /**
+   * Called when window becomes inactive.
+   * Override this method to provide functionality.
+   */
+  onLostFocus() {
+  }
+}
+v([
+  A()
+], I.prototype, "buttons", void 0);
+export {
+  I as BaseCameraPointersInput
+};

package/dist/node_modules/@babylonjs/core/Cameras/Inputs/arcRotateCameraKeyboardMoveInput.esm.js

@@ -0,0 +1,93 @@
+import { __decorate as s } from "../../tslib.es6.esm.js";
+import { serialize as n } from "../../Misc/decorators.esm.js";
+import { CameraInputTypes as a } from "../cameraInputsManager.esm.js";
+import { KeyboardEventTypes as h } from "../../Events/keyboardEvents.esm.js";
+import { Tools as l } from "../../Misc/tools.esm.js";
+class t {
+  constructor() {
+    this.keysUp = [38], this.keysDown = [40], this.keysLeft = [37], this.keysRight = [39], this.keysReset = [220], this.panningSensibility = 50, this.zoomingSensibility = 25, this.useAltToZoom = !0, this.angularSpeed = 0.01, this._keys = new Array();
+  }
+  /**
+   * Attach the input controls to a specific dom element to get the input from.
+   * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
+   */
+  attachControl(i) {
+    i = l.BackCompatCameraNoPreventDefault(arguments), !this._onCanvasBlurObserver && (this._scene = this.camera.getScene(), this._engine = this._scene.getEngine(), this._onCanvasBlurObserver = this._engine.onCanvasBlurObservable.add(() => {
+      this._keys.length = 0;
+    }), this._onKeyboardObserver = this._scene.onKeyboardObservable.add((r) => {
+      const e = r.event;
+      if (!e.metaKey) {
+        if (r.type === h.KEYDOWN)
+          this._ctrlPressed = e.ctrlKey, this._altPressed = e.altKey, (this.keysUp.indexOf(e.keyCode) !== -1 || this.keysDown.indexOf(e.keyCode) !== -1 || this.keysLeft.indexOf(e.keyCode) !== -1 || this.keysRight.indexOf(e.keyCode) !== -1 || this.keysReset.indexOf(e.keyCode) !== -1) && (this._keys.indexOf(e.keyCode) === -1 && this._keys.push(e.keyCode), e.preventDefault && (i || e.preventDefault()));
+        else if (this.keysUp.indexOf(e.keyCode) !== -1 || this.keysDown.indexOf(e.keyCode) !== -1 || this.keysLeft.indexOf(e.keyCode) !== -1 || this.keysRight.indexOf(e.keyCode) !== -1 || this.keysReset.indexOf(e.keyCode) !== -1) {
+          const o = this._keys.indexOf(e.keyCode);
+          o >= 0 && this._keys.splice(o, 1), e.preventDefault && (i || e.preventDefault());
+        }
+      }
+    }));
+  }
+  /**
+   * Detach the current controls from the specified dom element.
+   */
+  detachControl() {
+    this._scene && (this._onKeyboardObserver && this._scene.onKeyboardObservable.remove(this._onKeyboardObserver), this._onCanvasBlurObserver && this._engine.onCanvasBlurObservable.remove(this._onCanvasBlurObserver), this._onKeyboardObserver = null, this._onCanvasBlurObserver = null), this._keys.length = 0;
+  }
+  /**
+   * Update the current camera state depending on the inputs that have been used this frame.
+   * This is a dynamically created lambda to avoid the performance penalty of looping for inputs in the render loop.
+   */
+  checkInputs() {
+    if (this._onKeyboardObserver) {
+      const i = this.camera;
+      for (let r = 0; r < this._keys.length; r++) {
+        const e = this._keys[r];
+        this.keysLeft.indexOf(e) !== -1 ? this._ctrlPressed && this.camera._useCtrlForPanning ? i.inertialPanningX -= 1 / this.panningSensibility : i.inertialAlphaOffset -= this.angularSpeed : this.keysUp.indexOf(e) !== -1 ? this._ctrlPressed && this.camera._useCtrlForPanning ? i.inertialPanningY += 1 / this.panningSensibility : this._altPressed && this.useAltToZoom ? i.inertialRadiusOffset += 1 / this.zoomingSensibility : i.inertialBetaOffset -= this.angularSpeed : this.keysRight.indexOf(e) !== -1 ? this._ctrlPressed && this.camera._useCtrlForPanning ? i.inertialPanningX += 1 / this.panningSensibility : i.inertialAlphaOffset += this.angularSpeed : this.keysDown.indexOf(e) !== -1 ? this._ctrlPressed && this.camera._useCtrlForPanning ? i.inertialPanningY -= 1 / this.panningSensibility : this._altPressed && this.useAltToZoom ? i.inertialRadiusOffset -= 1 / this.zoomingSensibility : i.inertialBetaOffset += this.angularSpeed : this.keysReset.indexOf(e) !== -1 && i.useInputToRestoreState && i.restoreState();
+      }
+    }
+  }
+  /**
+   * Gets the class name of the current input.
+   * @returns the class name
+   */
+  getClassName() {
+    return "ArcRotateCameraKeyboardMoveInput";
+  }
+  /**
+   * Get the friendly name associated with the input class.
+   * @returns the input friendly name
+   */
+  getSimpleName() {
+    return "keyboard";
+  }
+}
+s([
+  n()
+], t.prototype, "keysUp", void 0);
+s([
+  n()
+], t.prototype, "keysDown", void 0);
+s([
+  n()
+], t.prototype, "keysLeft", void 0);
+s([
+  n()
+], t.prototype, "keysRight", void 0);
+s([
+  n()
+], t.prototype, "keysReset", void 0);
+s([
+  n()
+], t.prototype, "panningSensibility", void 0);
+s([
+  n()
+], t.prototype, "zoomingSensibility", void 0);
+s([
+  n()
+], t.prototype, "useAltToZoom", void 0);
+s([
+  n()
+], t.prototype, "angularSpeed", void 0);
+a.ArcRotateCameraKeyboardMoveInput = t;
+export {
+  t as ArcRotateCameraKeyboardMoveInput
+};

package/dist/node_modules/@babylonjs/core/Cameras/Inputs/arcRotateCameraMouseWheelInput.esm.js

@@ -0,0 +1,119 @@
+import { __decorate as u } from "../../tslib.es6.esm.js";
+import { serialize as f } from "../../Misc/decorators.esm.js";
+import { CameraInputTypes as d } from "../cameraInputsManager.esm.js";
+import { PointerEventTypes as p } from "../../Events/pointerEvents.esm.js";
+import { Plane as _ } from "../../Maths/math.plane.esm.js";
+import { Vector3 as P, Matrix as g, TmpVectors as M } from "../../Maths/math.vector.esm.js";
+import { Epsilon as h } from "../../Maths/math.constants.esm.js";
+import { EventConstants as v } from "../../Events/deviceInputEvents.esm.js";
+import { Scalar as L } from "../../Maths/math.scalar.esm.js";
+import { Tools as R } from "../../Misc/tools.esm.js";
+const C = 40;
+class m {
+  constructor() {
+    this.wheelPrecision = 3, this.zoomToMouseLocation = !1, this.wheelDeltaPercentage = 0, this.customComputeDeltaFromMouseWheel = null, this._inertialPanning = P.Zero();
+  }
+  _computeDeltaFromMouseWheelLegacyEvent(t, a) {
+    let i = 0;
+    const e = t * 0.01 * this.wheelDeltaPercentage * a;
+    return t > 0 ? i = e / (1 + this.wheelDeltaPercentage) : i = e * (1 + this.wheelDeltaPercentage), i;
+  }
+  /**
+   * Attach the input controls to a specific dom element to get the input from.
+   * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
+   */
+  attachControl(t) {
+    t = R.BackCompatCameraNoPreventDefault(arguments), this._wheel = (a) => {
+      if (a.type !== p.POINTERWHEEL)
+        return;
+      const i = a.event;
+      let e = 0;
+      const o = i.deltaMode === v.DOM_DELTA_LINE ? C : 1, n = -(i.deltaY * o);
+      if (this.customComputeDeltaFromMouseWheel)
+        e = this.customComputeDeltaFromMouseWheel(n, this, i);
+      else if (this.wheelDeltaPercentage) {
+        if (e = this._computeDeltaFromMouseWheelLegacyEvent(n, this.camera.radius), e > 0) {
+          let s = this.camera.radius, l = this.camera.inertialRadiusOffset + e;
+          for (let r = 0; r < 20 && Math.abs(l) > 1e-3; r++)
+            s -= l, l *= this.camera.inertia;
+          s = L.Clamp(s, 0, Number.MAX_VALUE), e = this._computeDeltaFromMouseWheelLegacyEvent(n, s);
+        }
+      } else
+        e = n / (this.wheelPrecision * 40);
+      e && (this.zoomToMouseLocation ? (this._hitPlane || this._updateHitPlane(), this._zoomToMouse(e)) : this.camera.inertialRadiusOffset += e), i.preventDefault && (t || i.preventDefault());
+    }, this._observer = this.camera.getScene()._inputManager._addCameraPointerObserver(this._wheel, p.POINTERWHEEL), this.zoomToMouseLocation && this._inertialPanning.setAll(0);
+  }
+  /**
+   * Detach the current controls from the specified dom element.
+   */
+  detachControl() {
+    this._observer && (this.camera.getScene()._inputManager._removeCameraPointerObserver(this._observer), this._observer = null, this._wheel = null);
+  }
+  /**
+   * Update the current camera state depending on the inputs that have been used this frame.
+   * This is a dynamically created lambda to avoid the performance penalty of looping for inputs in the render loop.
+   */
+  checkInputs() {
+    if (!this.zoomToMouseLocation)
+      return;
+    const t = this.camera;
+    0 + t.inertialAlphaOffset + t.inertialBetaOffset + t.inertialRadiusOffset && (this._updateHitPlane(), t.target.addInPlace(this._inertialPanning), this._inertialPanning.scaleInPlace(t.inertia), this._zeroIfClose(this._inertialPanning));
+  }
+  /**
+   * Gets the class name of the current input.
+   * @returns the class name
+   */
+  getClassName() {
+    return "ArcRotateCameraMouseWheelInput";
+  }
+  /**
+   * Get the friendly name associated with the input class.
+   * @returns the input friendly name
+   */
+  getSimpleName() {
+    return "mousewheel";
+  }
+  _updateHitPlane() {
+    const t = this.camera, a = t.target.subtract(t.position);
+    this._hitPlane = _.FromPositionAndNormal(t.target, a);
+  }
+  // Get position on the hit plane
+  _getPosition() {
+    var t;
+    const a = this.camera, i = a.getScene(), e = i.createPickingRay(i.pointerX, i.pointerY, g.Identity(), a, !1);
+    e.origin.x -= a.targetScreenOffset.x, e.origin.y -= a.targetScreenOffset.y;
+    let o = 0;
+    return this._hitPlane && (o = (t = e.intersectsPlane(this._hitPlane)) !== null && t !== void 0 ? t : 0), e.origin.addInPlace(e.direction.scaleInPlace(o));
+  }
+  _zoomToMouse(t) {
+    var a, i;
+    const e = this.camera, o = 1 - e.inertia;
+    if (e.lowerRadiusLimit) {
+      const c = (a = e.lowerRadiusLimit) !== null && a !== void 0 ? a : 0;
+      e.radius - (e.inertialRadiusOffset + t) / o < c && (t = (e.radius - c) * o - e.inertialRadiusOffset);
+    }
+    if (e.upperRadiusLimit) {
+      const c = (i = e.upperRadiusLimit) !== null && i !== void 0 ? i : 0;
+      e.radius - (e.inertialRadiusOffset + t) / o > c && (t = (e.radius - c) * o - e.inertialRadiusOffset);
+    }
+    const s = t / o / e.radius, l = this._getPosition(), r = M.Vector3[6];
+    l.subtractToRef(e.target, r), r.scaleInPlace(s), r.scaleInPlace(o), this._inertialPanning.addInPlace(r), e.inertialRadiusOffset += t;
+  }
+  // Sets x y or z of passed in vector to zero if less than Epsilon.
+  _zeroIfClose(t) {
+    Math.abs(t.x) < h && (t.x = 0), Math.abs(t.y) < h && (t.y = 0), Math.abs(t.z) < h && (t.z = 0);
+  }
+}
+u([
+  f()
+], m.prototype, "wheelPrecision", void 0);
+u([
+  f()
+], m.prototype, "zoomToMouseLocation", void 0);
+u([
+  f()
+], m.prototype, "wheelDeltaPercentage", void 0);
+d.ArcRotateCameraMouseWheelInput = m;
+export {
+  m as ArcRotateCameraMouseWheelInput
+};

package/dist/node_modules/@babylonjs/core/Cameras/Inputs/arcRotateCameraPointersInput.esm.js

@@ -0,0 +1,119 @@
+import { __decorate as e } from "../../tslib.es6.esm.js";
+import { serialize as a } from "../../Misc/decorators.esm.js";
+import { CameraInputTypes as l } from "../cameraInputsManager.esm.js";
+import { BaseCameraPointersInput as m } from "./BaseCameraPointersInput.esm.js";
+class i extends m {
+  constructor() {
+    super(...arguments), this.buttons = [0, 1, 2], this.angularSensibilityX = 1e3, this.angularSensibilityY = 1e3, this.pinchPrecision = 12, this.pinchDeltaPercentage = 0, this.useNaturalPinchZoom = !1, this.pinchZoom = !0, this.panningSensibility = 1e3, this.multiTouchPanning = !0, this.multiTouchPanAndZoom = !0, this.pinchInwards = !0, this._isPanClick = !1, this._twoFingerActivityCount = 0, this._isPinching = !1;
+  }
+  /**
+   * Gets the class name of the current input.
+   * @returns the class name
+   */
+  getClassName() {
+    return "ArcRotateCameraPointersInput";
+  }
+  /**
+   * Move camera from multi touch panning positions.
+   * @param previousMultiTouchPanPosition
+   * @param multiTouchPanPosition
+   */
+  _computeMultiTouchPanning(n, s) {
+    if (this.panningSensibility !== 0 && n && s) {
+      const t = s.x - n.x, o = s.y - n.y;
+      this.camera.inertialPanningX += -t / this.panningSensibility, this.camera.inertialPanningY += o / this.panningSensibility;
+    }
+  }
+  /**
+   * Move camera from pinch zoom distances.
+   * @param previousPinchSquaredDistance
+   * @param pinchSquaredDistance
+   */
+  _computePinchZoom(n, s) {
+    const t = this.camera.radius || i.MinimumRadiusForPinch;
+    this.useNaturalPinchZoom ? this.camera.radius = t * Math.sqrt(n) / Math.sqrt(s) : this.pinchDeltaPercentage ? this.camera.inertialRadiusOffset += (s - n) * 1e-3 * t * this.pinchDeltaPercentage : this.camera.inertialRadiusOffset += (s - n) / (this.pinchPrecision * (this.pinchInwards ? 1 : -1) * (this.angularSensibilityX + this.angularSensibilityY) / 2);
+  }
+  /**
+   * Called on pointer POINTERMOVE event if only a single touch is active.
+   * @param point
+   * @param offsetX
+   * @param offsetY
+   */
+  onTouch(n, s, t) {
+    this.panningSensibility !== 0 && (this._ctrlKey && this.camera._useCtrlForPanning || this._isPanClick) ? (this.camera.inertialPanningX += -s / this.panningSensibility, this.camera.inertialPanningY += t / this.panningSensibility) : (this.camera.inertialAlphaOffset -= s / this.angularSensibilityX, this.camera.inertialBetaOffset -= t / this.angularSensibilityY);
+  }
+  /**
+   * Called on pointer POINTERDOUBLETAP event.
+   */
+  onDoubleTap() {
+    this.camera.useInputToRestoreState && this.camera.restoreState();
+  }
+  /**
+   * Called on pointer POINTERMOVE event if multiple touches are active.
+   * @param pointA
+   * @param pointB
+   * @param previousPinchSquaredDistance
+   * @param pinchSquaredDistance
+   * @param previousMultiTouchPanPosition
+   * @param multiTouchPanPosition
+   */
+  onMultiTouch(n, s, t, o, h, r) {
+    t === 0 && h === null || o === 0 && r === null || (this.multiTouchPanAndZoom ? (this._computePinchZoom(t, o), this._computeMultiTouchPanning(h, r)) : this.multiTouchPanning && this.pinchZoom ? (this._twoFingerActivityCount++, this._isPinching || this._twoFingerActivityCount < 20 && Math.abs(Math.sqrt(o) - Math.sqrt(t)) > this.camera.pinchToPanMaxDistance ? (this._computePinchZoom(t, o), this._isPinching = !0) : this._computeMultiTouchPanning(h, r)) : this.multiTouchPanning ? this._computeMultiTouchPanning(h, r) : this.pinchZoom && this._computePinchZoom(t, o));
+  }
+  /**
+   * Called each time a new POINTERDOWN event occurs. Ie, for each button
+   * press.
+   * @param evt
+   */
+  onButtonDown(n) {
+    this._isPanClick = n.button === this.camera._panningMouseButton;
+  }
+  /**
+   * Called each time a new POINTERUP event occurs. Ie, for each button
+   * release.
+   */
+  onButtonUp() {
+    this._twoFingerActivityCount = 0, this._isPinching = !1;
+  }
+  /**
+   * Called when window becomes inactive.
+   */
+  onLostFocus() {
+    this._isPanClick = !1, this._twoFingerActivityCount = 0, this._isPinching = !1;
+  }
+}
+i.MinimumRadiusForPinch = 1e-3;
+e([
+  a()
+], i.prototype, "buttons", void 0);
+e([
+  a()
+], i.prototype, "angularSensibilityX", void 0);
+e([
+  a()
+], i.prototype, "angularSensibilityY", void 0);
+e([
+  a()
+], i.prototype, "pinchPrecision", void 0);
+e([
+  a()
+], i.prototype, "pinchDeltaPercentage", void 0);
+e([
+  a()
+], i.prototype, "useNaturalPinchZoom", void 0);
+e([
+  a()
+], i.prototype, "pinchZoom", void 0);
+e([
+  a()
+], i.prototype, "panningSensibility", void 0);
+e([
+  a()
+], i.prototype, "multiTouchPanning", void 0);
+e([
+  a()
+], i.prototype, "multiTouchPanAndZoom", void 0);
+l.ArcRotateCameraPointersInput = i;
+export {
+  i as ArcRotateCameraPointersInput
+};

package/dist/node_modules/@babylonjs/core/Cameras/Inputs/freeCameraKeyboardMoveInput.esm.js

@@ -0,0 +1,108 @@
+import { __decorate as i } from "../../tslib.es6.esm.js";
+import { serialize as s } from "../../Misc/decorators.esm.js";
+import { CameraInputTypes as n } from "../cameraInputsManager.esm.js";
+import { KeyboardEventTypes as y } from "../../Events/keyboardEvents.esm.js";
+import { Vector3 as d } from "../../Maths/math.vector.esm.js";
+import { Tools as h } from "../../Misc/tools.esm.js";
+class o {
+  constructor() {
+    this.keysUp = [38], this.keysUpward = [33], this.keysDown = [40], this.keysDownward = [34], this.keysLeft = [37], this.keysRight = [39], this.rotationSpeed = 0.5, this.keysRotateLeft = [], this.keysRotateRight = [], this.keysRotateUp = [], this.keysRotateDown = [], this._keys = new Array();
+  }
+  /**
+   * Attach the input controls to a specific dom element to get the input from.
+   * @param noPreventDefault Defines whether event caught by the controls should call preventdefault() (https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault)
+   */
+  attachControl(t) {
+    t = h.BackCompatCameraNoPreventDefault(arguments), !this._onCanvasBlurObserver && (this._scene = this.camera.getScene(), this._engine = this._scene.getEngine(), this._onCanvasBlurObserver = this._engine.onCanvasBlurObservable.add(() => {
+      this._keys.length = 0;
+    }), this._onKeyboardObserver = this._scene.onKeyboardObservable.add((r) => {
+      const e = r.event;
+      if (!e.metaKey) {
+        if (r.type === y.KEYDOWN)
+          (this.keysUp.indexOf(e.keyCode) !== -1 || this.keysDown.indexOf(e.keyCode) !== -1 || this.keysLeft.indexOf(e.keyCode) !== -1 || this.keysRight.indexOf(e.keyCode) !== -1 || this.keysUpward.indexOf(e.keyCode) !== -1 || this.keysDownward.indexOf(e.keyCode) !== -1 || this.keysRotateLeft.indexOf(e.keyCode) !== -1 || this.keysRotateRight.indexOf(e.keyCode) !== -1 || this.keysRotateUp.indexOf(e.keyCode) !== -1 || this.keysRotateDown.indexOf(e.keyCode) !== -1) && (this._keys.indexOf(e.keyCode) === -1 && this._keys.push(e.keyCode), t || e.preventDefault());
+        else if (this.keysUp.indexOf(e.keyCode) !== -1 || this.keysDown.indexOf(e.keyCode) !== -1 || this.keysLeft.indexOf(e.keyCode) !== -1 || this.keysRight.indexOf(e.keyCode) !== -1 || this.keysUpward.indexOf(e.keyCode) !== -1 || this.keysDownward.indexOf(e.keyCode) !== -1 || this.keysRotateLeft.indexOf(e.keyCode) !== -1 || this.keysRotateRight.indexOf(e.keyCode) !== -1 || this.keysRotateUp.indexOf(e.keyCode) !== -1 || this.keysRotateDown.indexOf(e.keyCode) !== -1) {
+          const a = this._keys.indexOf(e.keyCode);
+          a >= 0 && this._keys.splice(a, 1), t || e.preventDefault();
+        }
+      }
+    }));
+  }
+  /**
+   * Detach the current controls from the specified dom element.
+   */
+  detachControl() {
+    this._scene && (this._onKeyboardObserver && this._scene.onKeyboardObservable.remove(this._onKeyboardObserver), this._onCanvasBlurObserver && this._engine.onCanvasBlurObservable.remove(this._onCanvasBlurObserver), this._onKeyboardObserver = null, this._onCanvasBlurObserver = null), this._keys.length = 0;
+  }
+  /**
+   * Update the current camera state depending on the inputs that have been used this frame.
+   * This is a dynamically created lambda to avoid the performance penalty of looping for inputs in the render loop.
+   */
+  checkInputs() {
+    if (this._onKeyboardObserver) {
+      const t = this.camera;
+      for (let r = 0; r < this._keys.length; r++) {
+        const e = this._keys[r], a = t._computeLocalCameraSpeed();
+        this.keysLeft.indexOf(e) !== -1 ? t._localDirection.copyFromFloats(-a, 0, 0) : this.keysUp.indexOf(e) !== -1 ? t._localDirection.copyFromFloats(0, 0, a) : this.keysRight.indexOf(e) !== -1 ? t._localDirection.copyFromFloats(a, 0, 0) : this.keysDown.indexOf(e) !== -1 ? t._localDirection.copyFromFloats(0, 0, -a) : this.keysUpward.indexOf(e) !== -1 ? t._localDirection.copyFromFloats(0, a, 0) : this.keysDownward.indexOf(e) !== -1 ? t._localDirection.copyFromFloats(0, -a, 0) : this.keysRotateLeft.indexOf(e) !== -1 ? (t._localDirection.copyFromFloats(0, 0, 0), t.cameraRotation.y -= this._getLocalRotation()) : this.keysRotateRight.indexOf(e) !== -1 ? (t._localDirection.copyFromFloats(0, 0, 0), t.cameraRotation.y += this._getLocalRotation()) : this.keysRotateUp.indexOf(e) !== -1 ? (t._localDirection.copyFromFloats(0, 0, 0), t.cameraRotation.x -= this._getLocalRotation()) : this.keysRotateDown.indexOf(e) !== -1 && (t._localDirection.copyFromFloats(0, 0, 0), t.cameraRotation.x += this._getLocalRotation()), t.getScene().useRightHandedSystem && (t._localDirection.z *= -1), t.getViewMatrix().invertToRef(t._cameraTransformMatrix), d.TransformNormalToRef(t._localDirection, t._cameraTransformMatrix, t._transformedDirection), t.cameraDirection.addInPlace(t._transformedDirection);
+      }
+    }
+  }
+  /**
+   * Gets the class name of the current input.
+   * @returns the class name
+   */
+  getClassName() {
+    return "FreeCameraKeyboardMoveInput";
+  }
+  /** @internal */
+  _onLostFocus() {
+    this._keys.length = 0;
+  }
+  /**
+   * Get the friendly name associated with the input class.
+   * @returns the input friendly name
+   */
+  getSimpleName() {
+    return "keyboard";
+  }
+  _getLocalRotation() {
+    let t = this.rotationSpeed * this._engine.getDeltaTime() / 1e3;
+    return this.camera.getScene().useRightHandedSystem && (t *= -1), this.camera.parent && this.camera.parent._getWorldMatrixDeterminant() < 0 && (t *= -1), t;
+  }
+}
+i([
+  s()
+], o.prototype, "keysUp", void 0);
+i([
+  s()
+], o.prototype, "keysUpward", void 0);
+i([
+  s()
+], o.prototype, "keysDown", void 0);
+i([
+  s()
+], o.prototype, "keysDownward", void 0);
+i([
+  s()
+], o.prototype, "keysLeft", void 0);
+i([
+  s()
+], o.prototype, "keysRight", void 0);
+i([
+  s()
+], o.prototype, "rotationSpeed", void 0);
+i([
+  s()
+], o.prototype, "keysRotateLeft", void 0);
+i([
+  s()
+], o.prototype, "keysRotateRight", void 0);
+i([
+  s()
+], o.prototype, "keysRotateUp", void 0);
+i([
+  s()
+], o.prototype, "keysRotateDown", void 0);
+n.FreeCameraKeyboardMoveInput = o;
+export {
+  o as FreeCameraKeyboardMoveInput
+};