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

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

@@ -0,0 +1,686 @@
+import { __decorate as n } from "../tslib.es6.esm.js";
+import { SerializationHelper as p, serializeAsVector3 as y, serialize as h } from "../Misc/decorators.esm.js";
+import { SmartArray as I } from "../Misc/smartArray.esm.js";
+import { Tools as v } from "../Misc/tools.esm.js";
+import { Observable as R } from "../Misc/observable.esm.js";
+import { Vector3 as l, Matrix as c, Quaternion as O } from "../Maths/math.vector.esm.js";
+import { Node as M } from "../node.esm.js";
+import { Logger as T } from "../Misc/logger.esm.js";
+import { GetClass as V } from "../Misc/typeStore.esm.js";
+import { _WarnImport as x } from "../Misc/devTools.esm.js";
+import { Viewport as S } from "../Maths/math.viewport.esm.js";
+import { Frustum as E } from "../Maths/math.frustum.esm.js";
+class i extends M {
+  /**
+   * Define the current local position of the camera in the scene
+   */
+  get position() {
+    return this._position;
+  }
+  set position(t) {
+    this._position = t;
+  }
+  /**
+   * The vector the camera should consider as up.
+   * (default is Vector3(0, 1, 0) aka Vector3.Up())
+   */
+  set upVector(t) {
+    this._upVector = t;
+  }
+  get upVector() {
+    return this._upVector;
+  }
+  /**
+   * The screen area in scene units squared
+   */
+  get screenArea() {
+    var t, e, s, o;
+    let r = 0, a = 0;
+    if (this.mode === i.PERSPECTIVE_CAMERA)
+      this.fovMode === i.FOVMODE_VERTICAL_FIXED ? (a = this.minZ * 2 * Math.tan(this.fov / 2), r = this.getEngine().getAspectRatio(this) * a) : (r = this.minZ * 2 * Math.tan(this.fov / 2), a = r / this.getEngine().getAspectRatio(this));
+    else {
+      const m = this.getEngine().getRenderWidth() / 2, u = this.getEngine().getRenderHeight() / 2;
+      r = ((t = this.orthoRight) !== null && t !== void 0 ? t : m) - ((e = this.orthoLeft) !== null && e !== void 0 ? e : -m), a = ((s = this.orthoTop) !== null && s !== void 0 ? s : u) - ((o = this.orthoBottom) !== null && o !== void 0 ? o : -u);
+    }
+    return r * a;
+  }
+  set orthoLeft(t) {
+    this._orthoLeft = t;
+    for (const e of this._rigCameras)
+      e.orthoLeft = t;
+  }
+  get orthoLeft() {
+    return this._orthoLeft;
+  }
+  set orthoRight(t) {
+    this._orthoRight = t;
+    for (const e of this._rigCameras)
+      e.orthoRight = t;
+  }
+  get orthoRight() {
+    return this._orthoRight;
+  }
+  set orthoBottom(t) {
+    this._orthoBottom = t;
+    for (const e of this._rigCameras)
+      e.orthoBottom = t;
+  }
+  get orthoBottom() {
+    return this._orthoBottom;
+  }
+  set orthoTop(t) {
+    this._orthoTop = t;
+    for (const e of this._rigCameras)
+      e.orthoTop = t;
+  }
+  get orthoTop() {
+    return this._orthoTop;
+  }
+  set mode(t) {
+    this._mode = t;
+    for (const e of this._rigCameras)
+      e.mode = t;
+  }
+  get mode() {
+    return this._mode;
+  }
+  /**
+   * Instantiates a new camera object.
+   * This should not be used directly but through the inherited cameras: ArcRotate, Free...
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras
+   * @param name Defines the name of the camera in the scene
+   * @param position Defines the position of the camera
+   * @param scene Defines the scene the camera belongs too
+   * @param setActiveOnSceneIfNoneActive Defines if the camera should be set as active after creation if no other camera have been defined in the scene
+   */
+  constructor(t, e, s, o = !0) {
+    super(t, s), this._position = l.Zero(), this._upVector = l.Up(), this._orthoLeft = null, this._orthoRight = null, this._orthoBottom = null, this._orthoTop = null, this.fov = 0.8, this.projectionPlaneTilt = 0, this.minZ = 1, this.maxZ = 1e4, this.inertia = 0.9, this._mode = i.PERSPECTIVE_CAMERA, this.isIntermediate = !1, this.viewport = new S(0, 0, 1, 1), this.layerMask = 268435455, this.fovMode = i.FOVMODE_VERTICAL_FIXED, this.cameraRigMode = i.RIG_MODE_NONE, this.customRenderTargets = new Array(), this.outputRenderTarget = null, this.onViewMatrixChangedObservable = new R(), this.onProjectionMatrixChangedObservable = new R(), this.onAfterCheckInputsObservable = new R(), this.onRestoreStateObservable = new R(), this.isRigCamera = !1, this._rigCameras = new Array(), this._webvrViewMatrix = c.Identity(), this._skipRendering = !1, this._projectionMatrix = new c(), this._postProcesses = new Array(), this._activeMeshes = new I(256), this._globalPosition = l.Zero(), this._computedViewMatrix = c.Identity(), this._doNotComputeProjectionMatrix = !1, this._transformMatrix = c.Zero(), this._refreshFrustumPlanes = !0, this._absoluteRotation = O.Identity(), this._isCamera = !0, this._isLeftCamera = !1, this._isRightCamera = !1, this.getScene().addCamera(this), o && !this.getScene().activeCamera && (this.getScene().activeCamera = this), this.position = e, this.renderPassId = this.getScene().getEngine().createRenderPassId(`Camera ${t}`);
+  }
+  /**
+   * Store current camera state (fov, position, etc..)
+   * @returns the camera
+   */
+  storeState() {
+    return this._stateStored = !0, this._storedFov = this.fov, this;
+  }
+  /**
+   * Restores the camera state values if it has been stored. You must call storeState() first
+   */
+  _restoreStateValues() {
+    return this._stateStored ? (this.fov = this._storedFov, !0) : !1;
+  }
+  /**
+   * Restored camera state. You must call storeState() first.
+   * @returns true if restored and false otherwise
+   */
+  restoreState() {
+    return this._restoreStateValues() ? (this.onRestoreStateObservable.notifyObservers(this), !0) : !1;
+  }
+  /**
+   * Gets the class name of the camera.
+   * @returns the class name
+   */
+  getClassName() {
+    return "Camera";
+  }
+  /**
+   * Gets a string representation of the camera useful for debug purpose.
+   * @param fullDetails Defines that a more verbose level of logging is required
+   * @returns the string representation
+   */
+  toString(t) {
+    let e = "Name: " + this.name;
+    if (e += ", type: " + this.getClassName(), this.animations)
+      for (let s = 0; s < this.animations.length; s++)
+        e += ", animation[0]: " + this.animations[s].toString(t);
+    return e;
+  }
+  /**
+   * Automatically tilts the projection plane, using `projectionPlaneTilt`, to correct the perspective effect on vertical lines.
+   */
+  applyVerticalCorrection() {
+    const t = this.absoluteRotation.toEulerAngles();
+    this.projectionPlaneTilt = this._scene.useRightHandedSystem ? -t.x : t.x;
+  }
+  /**
+   * Gets the current world space position of the camera.
+   */
+  get globalPosition() {
+    return this._globalPosition;
+  }
+  /**
+   * Gets the list of active meshes this frame (meshes no culled or excluded by lod s in the frame)
+   * @returns the active meshe list
+   */
+  getActiveMeshes() {
+    return this._activeMeshes;
+  }
+  /**
+   * Check whether a mesh is part of the current active mesh list of the camera
+   * @param mesh Defines the mesh to check
+   * @returns true if active, false otherwise
+   */
+  isActiveMesh(t) {
+    return this._activeMeshes.indexOf(t) !== -1;
+  }
+  /**
+   * Is this camera ready to be used/rendered
+   * @param completeCheck defines if a complete check (including post processes) has to be done (false by default)
+   * @returns true if the camera is ready
+   */
+  isReady(t = !1) {
+    if (t) {
+      for (const e of this._postProcesses)
+        if (e && !e.isReady())
+          return !1;
+    }
+    return super.isReady(t);
+  }
+  /** @internal */
+  _initCache() {
+    super._initCache(), this._cache.position = new l(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE), this._cache.upVector = new l(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE), this._cache.mode = void 0, this._cache.minZ = void 0, this._cache.maxZ = void 0, this._cache.fov = void 0, this._cache.fovMode = void 0, this._cache.aspectRatio = void 0, this._cache.orthoLeft = void 0, this._cache.orthoRight = void 0, this._cache.orthoBottom = void 0, this._cache.orthoTop = void 0, this._cache.renderWidth = void 0, this._cache.renderHeight = void 0;
+  }
+  /**
+   * @internal
+   */
+  _updateCache(t) {
+    t || super._updateCache(), this._cache.position.copyFrom(this.position), this._cache.upVector.copyFrom(this.upVector);
+  }
+  /** @internal */
+  _isSynchronized() {
+    return this._isSynchronizedViewMatrix() && this._isSynchronizedProjectionMatrix();
+  }
+  /** @internal */
+  _isSynchronizedViewMatrix() {
+    return super._isSynchronized() ? this._cache.position.equals(this.position) && this._cache.upVector.equals(this.upVector) && this.isSynchronizedWithParent() : !1;
+  }
+  /** @internal */
+  _isSynchronizedProjectionMatrix() {
+    let t = this._cache.mode === this.mode && this._cache.minZ === this.minZ && this._cache.maxZ === this.maxZ;
+    if (!t)
+      return !1;
+    const e = this.getEngine();
+    return this.mode === i.PERSPECTIVE_CAMERA ? t = this._cache.fov === this.fov && this._cache.fovMode === this.fovMode && this._cache.aspectRatio === e.getAspectRatio(this) && this._cache.projectionPlaneTilt === this.projectionPlaneTilt : t = this._cache.orthoLeft === this.orthoLeft && this._cache.orthoRight === this.orthoRight && this._cache.orthoBottom === this.orthoBottom && this._cache.orthoTop === this.orthoTop && this._cache.renderWidth === e.getRenderWidth() && this._cache.renderHeight === e.getRenderHeight(), t;
+  }
+  /**
+   * Attach the input controls to a specific dom element to get the input from.
+   * This function is here because typescript removes the typing of the last function.
+   * @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) {
+  }
+  /**
+   * Detach the current controls from the specified dom element.
+   * This function is here because typescript removes the typing of the last function.
+   * @param _ignored defines an ignored parameter kept for backward compatibility.
+   */
+  detachControl(t) {
+  }
+  /**
+   * Update the camera state according to the different inputs gathered during the frame.
+   */
+  update() {
+    this._checkInputs(), this.cameraRigMode !== i.RIG_MODE_NONE && this._updateRigCameras(), this.getViewMatrix(), this.getProjectionMatrix();
+  }
+  /** @internal */
+  _checkInputs() {
+    this.onAfterCheckInputsObservable.notifyObservers(this);
+  }
+  /** @internal */
+  get rigCameras() {
+    return this._rigCameras;
+  }
+  /**
+   * Gets the post process used by the rig cameras
+   */
+  get rigPostProcess() {
+    return this._rigPostProcess;
+  }
+  /**
+   * Internal, gets the first post process.
+   * @returns the first post process to be run on this camera.
+   */
+  _getFirstPostProcess() {
+    for (let t = 0; t < this._postProcesses.length; t++)
+      if (this._postProcesses[t] !== null)
+        return this._postProcesses[t];
+    return null;
+  }
+  _cascadePostProcessesToRigCams() {
+    const t = this._getFirstPostProcess();
+    t && t.markTextureDirty();
+    for (let e = 0, s = this._rigCameras.length; e < s; e++) {
+      const o = this._rigCameras[e], r = o._rigPostProcess;
+      r ? (r.getEffectName() === "pass" && (o.isIntermediate = this._postProcesses.length === 0), o._postProcesses = this._postProcesses.slice(0).concat(r), r.markTextureDirty()) : o._postProcesses = this._postProcesses.slice(0);
+    }
+  }
+  /**
+   * Attach a post process to the camera.
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/postProcesses/usePostProcesses#attach-postprocess
+   * @param postProcess The post process to attach to the camera
+   * @param insertAt The position of the post process in case several of them are in use in the scene
+   * @returns the position the post process has been inserted at
+   */
+  attachPostProcess(t, e = null) {
+    return !t.isReusable() && this._postProcesses.indexOf(t) > -1 ? (T.Error("You're trying to reuse a post process not defined as reusable."), 0) : (e == null || e < 0 ? this._postProcesses.push(t) : this._postProcesses[e] === null ? this._postProcesses[e] = t : this._postProcesses.splice(e, 0, t), this._cascadePostProcessesToRigCams(), this._scene.prePassRenderer && this._scene.prePassRenderer.markAsDirty(), this._postProcesses.indexOf(t));
+  }
+  /**
+   * Detach a post process to the camera.
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/postProcesses/usePostProcesses#attach-postprocess
+   * @param postProcess The post process to detach from the camera
+   */
+  detachPostProcess(t) {
+    const e = this._postProcesses.indexOf(t);
+    e !== -1 && (this._postProcesses[e] = null), this._scene.prePassRenderer && this._scene.prePassRenderer.markAsDirty(), this._cascadePostProcessesToRigCams();
+  }
+  /**
+   * Gets the current world matrix of the camera
+   */
+  getWorldMatrix() {
+    return this._isSynchronizedViewMatrix() ? this._worldMatrix : (this.getViewMatrix(), this._worldMatrix);
+  }
+  /** @internal */
+  _getViewMatrix() {
+    return c.Identity();
+  }
+  /**
+   * Gets the current view matrix of the camera.
+   * @param force forces the camera to recompute the matrix without looking at the cached state
+   * @returns the view matrix
+   */
+  getViewMatrix(t) {
+    return !t && this._isSynchronizedViewMatrix() ? this._computedViewMatrix : (this.updateCache(), this._computedViewMatrix = this._getViewMatrix(), this._currentRenderId = this.getScene().getRenderId(), this._childUpdateId++, this._refreshFrustumPlanes = !0, this._cameraRigParams && this._cameraRigParams.vrPreViewMatrix && this._computedViewMatrix.multiplyToRef(this._cameraRigParams.vrPreViewMatrix, this._computedViewMatrix), this.parent && this.parent.onViewMatrixChangedObservable && this.parent.onViewMatrixChangedObservable.notifyObservers(this.parent), this.onViewMatrixChangedObservable.notifyObservers(this), this._computedViewMatrix.invertToRef(this._worldMatrix), this._computedViewMatrix);
+  }
+  /**
+   * Freeze the projection matrix.
+   * It will prevent the cache check of the camera projection compute and can speed up perf
+   * if no parameter of the camera are meant to change
+   * @param projection Defines manually a projection if necessary
+   */
+  freezeProjectionMatrix(t) {
+    this._doNotComputeProjectionMatrix = !0, t !== void 0 && (this._projectionMatrix = t);
+  }
+  /**
+   * Unfreeze the projection matrix if it has previously been freezed by freezeProjectionMatrix.
+   */
+  unfreezeProjectionMatrix() {
+    this._doNotComputeProjectionMatrix = !1;
+  }
+  /**
+   * Gets the current projection matrix of the camera.
+   * @param force forces the camera to recompute the matrix without looking at the cached state
+   * @returns the projection matrix
+   */
+  getProjectionMatrix(t) {
+    var e, s, o, r, a, m, u, P;
+    if (this._doNotComputeProjectionMatrix || !t && this._isSynchronizedProjectionMatrix())
+      return this._projectionMatrix;
+    this._cache.mode = this.mode, this._cache.minZ = this.minZ, this._cache.maxZ = this.maxZ, this._refreshFrustumPlanes = !0;
+    const _ = this.getEngine(), C = this.getScene(), f = _.useReverseDepthBuffer;
+    if (this.mode === i.PERSPECTIVE_CAMERA) {
+      this._cache.fov = this.fov, this._cache.fovMode = this.fovMode, this._cache.aspectRatio = _.getAspectRatio(this), this._cache.projectionPlaneTilt = this.projectionPlaneTilt, this.minZ <= 0 && (this.minZ = 0.1);
+      let g;
+      C.useRightHandedSystem ? g = c.PerspectiveFovRHToRef : g = c.PerspectiveFovLHToRef, g(this.fov, _.getAspectRatio(this), f ? this.maxZ : this.minZ, f ? this.minZ : this.maxZ, this._projectionMatrix, this.fovMode === i.FOVMODE_VERTICAL_FIXED, _.isNDCHalfZRange, this.projectionPlaneTilt, f);
+    } else {
+      const g = _.getRenderWidth() / 2, d = _.getRenderHeight() / 2;
+      C.useRightHandedSystem ? c.OrthoOffCenterRHToRef((e = this.orthoLeft) !== null && e !== void 0 ? e : -g, (s = this.orthoRight) !== null && s !== void 0 ? s : g, (o = this.orthoBottom) !== null && o !== void 0 ? o : -d, (r = this.orthoTop) !== null && r !== void 0 ? r : d, f ? this.maxZ : this.minZ, f ? this.minZ : this.maxZ, this._projectionMatrix, _.isNDCHalfZRange) : c.OrthoOffCenterLHToRef((a = this.orthoLeft) !== null && a !== void 0 ? a : -g, (m = this.orthoRight) !== null && m !== void 0 ? m : g, (u = this.orthoBottom) !== null && u !== void 0 ? u : -d, (P = this.orthoTop) !== null && P !== void 0 ? P : d, f ? this.maxZ : this.minZ, f ? this.minZ : this.maxZ, this._projectionMatrix, _.isNDCHalfZRange), this._cache.orthoLeft = this.orthoLeft, this._cache.orthoRight = this.orthoRight, this._cache.orthoBottom = this.orthoBottom, this._cache.orthoTop = this.orthoTop, this._cache.renderWidth = _.getRenderWidth(), this._cache.renderHeight = _.getRenderHeight();
+    }
+    return this.onProjectionMatrixChangedObservable.notifyObservers(this), this._projectionMatrix;
+  }
+  /**
+   * Gets the transformation matrix (ie. the multiplication of view by projection matrices)
+   * @returns a Matrix
+   */
+  getTransformationMatrix() {
+    return this._computedViewMatrix.multiplyToRef(this._projectionMatrix, this._transformMatrix), this._transformMatrix;
+  }
+  _updateFrustumPlanes() {
+    this._refreshFrustumPlanes && (this.getTransformationMatrix(), this._frustumPlanes ? E.GetPlanesToRef(this._transformMatrix, this._frustumPlanes) : this._frustumPlanes = E.GetPlanes(this._transformMatrix), this._refreshFrustumPlanes = !1);
+  }
+  /**
+   * Checks if a cullable object (mesh...) is in the camera frustum
+   * This checks the bounding box center. See isCompletelyInFrustum for a full bounding check
+   * @param target The object to check
+   * @param checkRigCameras If the rig cameras should be checked (eg. with webVR camera both eyes should be checked) (Default: false)
+   * @returns true if the object is in frustum otherwise false
+   */
+  isInFrustum(t, e = !1) {
+    if (this._updateFrustumPlanes(), e && this.rigCameras.length > 0) {
+      let s = !1;
+      return this.rigCameras.forEach((o) => {
+        o._updateFrustumPlanes(), s = s || t.isInFrustum(o._frustumPlanes);
+      }), s;
+    } else
+      return t.isInFrustum(this._frustumPlanes);
+  }
+  /**
+   * Checks if a cullable object (mesh...) is in the camera frustum
+   * Unlike isInFrustum this checks the full bounding box
+   * @param target The object to check
+   * @returns true if the object is in frustum otherwise false
+   */
+  isCompletelyInFrustum(t) {
+    return this._updateFrustumPlanes(), t.isCompletelyInFrustum(this._frustumPlanes);
+  }
+  /**
+   * Gets a ray in the forward direction from the camera.
+   * @param length Defines the length of the ray to create
+   * @param transform Defines the transform to apply to the ray, by default the world matrix is used to create a workd space ray
+   * @param origin Defines the start point of the ray which defaults to the camera position
+   * @returns the forward ray
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getForwardRay(t = 100, e, s) {
+    throw x("Ray");
+  }
+  /**
+   * Gets a ray in the forward direction from the camera.
+   * @param refRay the ray to (re)use when setting the values
+   * @param length Defines the length of the ray to create
+   * @param transform Defines the transform to apply to the ray, by default the world matrx is used to create a workd space ray
+   * @param origin Defines the start point of the ray which defaults to the camera position
+   * @returns the forward ray
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getForwardRayToRef(t, e = 100, s, o) {
+    throw x("Ray");
+  }
+  /**
+   * Releases resources associated with this node.
+   * @param doNotRecurse Set to true to not recurse into each children (recurse into each children by default)
+   * @param disposeMaterialAndTextures Set to true to also dispose referenced materials and textures (false by default)
+   */
+  dispose(t, e = !1) {
+    for (this.onViewMatrixChangedObservable.clear(), this.onProjectionMatrixChangedObservable.clear(), this.onAfterCheckInputsObservable.clear(), this.onRestoreStateObservable.clear(), this.inputs && this.inputs.clear(), this.getScene().stopAnimation(this), this.getScene().removeCamera(this); this._rigCameras.length > 0; ) {
+      const o = this._rigCameras.pop();
+      o && o.dispose();
+    }
+    if (this._parentContainer) {
+      const o = this._parentContainer.cameras.indexOf(this);
+      o > -1 && this._parentContainer.cameras.splice(o, 1), this._parentContainer = null;
+    }
+    if (this._rigPostProcess)
+      this._rigPostProcess.dispose(this), this._rigPostProcess = null, this._postProcesses.length = 0;
+    else if (this.cameraRigMode !== i.RIG_MODE_NONE)
+      this._rigPostProcess = null, this._postProcesses.length = 0;
+    else {
+      let o = this._postProcesses.length;
+      for (; --o >= 0; ) {
+        const r = this._postProcesses[o];
+        r && r.dispose(this);
+      }
+    }
+    let s = this.customRenderTargets.length;
+    for (; --s >= 0; )
+      this.customRenderTargets[s].dispose();
+    this.customRenderTargets.length = 0, this._activeMeshes.dispose(), this.getScene().getEngine().releaseRenderPassId(this.renderPassId), super.dispose(t, e);
+  }
+  /**
+   * Gets the left camera of a rig setup in case of Rigged Camera
+   */
+  get isLeftCamera() {
+    return this._isLeftCamera;
+  }
+  /**
+   * Gets the right camera of a rig setup in case of Rigged Camera
+   */
+  get isRightCamera() {
+    return this._isRightCamera;
+  }
+  /**
+   * Gets the left camera of a rig setup in case of Rigged Camera
+   */
+  get leftCamera() {
+    return this._rigCameras.length < 1 ? null : this._rigCameras[0];
+  }
+  /**
+   * Gets the right camera of a rig setup in case of Rigged Camera
+   */
+  get rightCamera() {
+    return this._rigCameras.length < 2 ? null : this._rigCameras[1];
+  }
+  /**
+   * Gets the left camera target of a rig setup in case of Rigged Camera
+   * @returns the target position
+   */
+  getLeftTarget() {
+    return this._rigCameras.length < 1 ? null : this._rigCameras[0].getTarget();
+  }
+  /**
+   * Gets the right camera target of a rig setup in case of Rigged Camera
+   * @returns the target position
+   */
+  getRightTarget() {
+    return this._rigCameras.length < 2 ? null : this._rigCameras[1].getTarget();
+  }
+  /**
+   * @internal
+   */
+  setCameraRigMode(t, e) {
+    if (this.cameraRigMode !== t) {
+      for (; this._rigCameras.length > 0; ) {
+        const s = this._rigCameras.pop();
+        s && s.dispose();
+      }
+      if (this.cameraRigMode = t, this._cameraRigParams = {}, this._cameraRigParams.interaxialDistance = e.interaxialDistance || 0.0637, this._cameraRigParams.stereoHalfAngle = v.ToRadians(this._cameraRigParams.interaxialDistance / 0.0637), this.cameraRigMode !== i.RIG_MODE_NONE) {
+        const s = this.createRigCamera(this.name + "_L", 0);
+        s && (s._isLeftCamera = !0);
+        const o = this.createRigCamera(this.name + "_R", 1);
+        o && (o._isRightCamera = !0), s && o && (this._rigCameras.push(s), this._rigCameras.push(o));
+      }
+      this._setRigMode(e), this._cascadePostProcessesToRigCams(), this.update();
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _setRigMode(t) {
+  }
+  /** @internal */
+  _getVRProjectionMatrix() {
+    return c.PerspectiveFovLHToRef(this._cameraRigParams.vrMetrics.aspectRatioFov, this._cameraRigParams.vrMetrics.aspectRatio, this.minZ, this.maxZ, this._cameraRigParams.vrWorkMatrix, !0, this.getEngine().isNDCHalfZRange), this._cameraRigParams.vrWorkMatrix.multiplyToRef(this._cameraRigParams.vrHMatrix, this._projectionMatrix), this._projectionMatrix;
+  }
+  _updateCameraRotationMatrix() {
+  }
+  _updateWebVRCameraRotationMatrix() {
+  }
+  /**
+   * This function MUST be overwritten by the different WebVR cameras available.
+   * The context in which it is running is the RIG camera. So 'this' is the TargetCamera, left or right.
+   * @internal
+   */
+  _getWebVRProjectionMatrix() {
+    return c.Identity();
+  }
+  /**
+   * This function MUST be overwritten by the different WebVR cameras available.
+   * The context in which it is running is the RIG camera. So 'this' is the TargetCamera, left or right.
+   * @internal
+   */
+  _getWebVRViewMatrix() {
+    return c.Identity();
+  }
+  /**
+   * @internal
+   */
+  setCameraRigParameter(t, e) {
+    this._cameraRigParams || (this._cameraRigParams = {}), this._cameraRigParams[t] = e, t === "interaxialDistance" && (this._cameraRigParams.stereoHalfAngle = v.ToRadians(e / 0.0637));
+  }
+  /**
+   * needs to be overridden by children so sub has required properties to be copied
+   * @internal
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  createRigCamera(t, e) {
+    return null;
+  }
+  /**
+   * May need to be overridden by children
+   * @internal
+   */
+  _updateRigCameras() {
+    for (let t = 0; t < this._rigCameras.length; t++)
+      this._rigCameras[t].minZ = this.minZ, this._rigCameras[t].maxZ = this.maxZ, this._rigCameras[t].fov = this.fov, this._rigCameras[t].upVector.copyFrom(this.upVector);
+    this.cameraRigMode === i.RIG_MODE_STEREOSCOPIC_ANAGLYPH && (this._rigCameras[0].viewport = this._rigCameras[1].viewport = this.viewport);
+  }
+  /** @internal */
+  _setupInputs() {
+  }
+  /**
+   * Serialiaze the camera setup to a json representation
+   * @returns the JSON representation
+   */
+  serialize() {
+    const t = p.Serialize(this);
+    return t.uniqueId = this.uniqueId, t.type = this.getClassName(), this.parent && this.parent._serializeAsParent(t), this.inputs && this.inputs.serialize(t), p.AppendSerializedAnimations(this, t), t.ranges = this.serializeAnimationRanges(), t.isEnabled = this.isEnabled(), t;
+  }
+  /**
+   * Clones the current camera.
+   * @param name The cloned camera name
+   * @param newParent The cloned camera's new parent (none by default)
+   * @returns the cloned camera
+   */
+  clone(t, e = null) {
+    const s = p.Clone(i.GetConstructorFromName(this.getClassName(), t, this.getScene(), this.interaxialDistance, this.isStereoscopicSideBySide), this);
+    return s.name = t, s.parent = e, this.onClonedObservable.notifyObservers(s), s;
+  }
+  /**
+   * Gets the direction of the camera relative to a given local axis.
+   * @param localAxis Defines the reference axis to provide a relative direction.
+   * @returns the direction
+   */
+  getDirection(t) {
+    const e = l.Zero();
+    return this.getDirectionToRef(t, e), e;
+  }
+  /**
+   * Returns the current camera absolute rotation
+   */
+  get absoluteRotation() {
+    return this.getWorldMatrix().decompose(void 0, this._absoluteRotation), this._absoluteRotation;
+  }
+  /**
+   * Gets the direction of the camera relative to a given local axis into a passed vector.
+   * @param localAxis Defines the reference axis to provide a relative direction.
+   * @param result Defines the vector to store the result in
+   */
+  getDirectionToRef(t, e) {
+    l.TransformNormalToRef(t, this.getWorldMatrix(), e);
+  }
+  /**
+   * Gets a camera constructor for a given camera type
+   * @param type The type of the camera to construct (should be equal to one of the camera class name)
+   * @param name The name of the camera the result will be able to instantiate
+   * @param scene The scene the result will construct the camera in
+   * @param interaxial_distance In case of stereoscopic setup, the distance between both eyes
+   * @param isStereoscopicSideBySide In case of stereoscopic setup, should the sereo be side b side
+   * @returns a factory method to construct the camera
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static GetConstructorFromName(t, e, s, o = 0, r = !0) {
+    const a = M.Construct(t, e, s, {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      interaxial_distance: o,
+      isStereoscopicSideBySide: r
+    });
+    return a || (() => i._CreateDefaultParsedCamera(e, s));
+  }
+  /**
+   * Compute the world  matrix of the camera.
+   * @returns the camera world matrix
+   */
+  computeWorldMatrix() {
+    return this.getWorldMatrix();
+  }
+  /**
+   * Parse a JSON and creates the camera from the parsed information
+   * @param parsedCamera The JSON to parse
+   * @param scene The scene to instantiate the camera in
+   * @returns the newly constructed camera
+   */
+  static Parse(t, e) {
+    const s = t.type, o = i.GetConstructorFromName(s, t.name, e, t.interaxial_distance, t.isStereoscopicSideBySide), r = p.Parse(o, t, e);
+    if (t.parentId !== void 0 && (r._waitingParentId = t.parentId), t.parentInstanceIndex !== void 0 && (r._waitingParentInstanceIndex = t.parentInstanceIndex), r.inputs && (r.inputs.parse(t), r._setupInputs()), t.upVector && (r.upVector = l.FromArray(t.upVector)), r.setPosition && (r.position.copyFromFloats(0, 0, 0), r.setPosition(l.FromArray(t.position))), t.target && r.setTarget && r.setTarget(l.FromArray(t.target)), t.cameraRigMode) {
+      const a = t.interaxial_distance ? { interaxialDistance: t.interaxial_distance } : {};
+      r.setCameraRigMode(t.cameraRigMode, a);
+    }
+    if (t.animations) {
+      for (let a = 0; a < t.animations.length; a++) {
+        const m = t.animations[a], u = V("BABYLON.Animation");
+        u && r.animations.push(u.Parse(m));
+      }
+      M.ParseAnimationRanges(r, t, e);
+    }
+    return t.autoAnimate && e.beginAnimation(r, t.autoAnimateFrom, t.autoAnimateTo, t.autoAnimateLoop, t.autoAnimateSpeed || 1), t.isEnabled !== void 0 && r.setEnabled(t.isEnabled), r;
+  }
+}
+i._CreateDefaultParsedCamera = (A, t) => {
+  throw x("UniversalCamera");
+};
+i.PERSPECTIVE_CAMERA = 0;
+i.ORTHOGRAPHIC_CAMERA = 1;
+i.FOVMODE_VERTICAL_FIXED = 0;
+i.FOVMODE_HORIZONTAL_FIXED = 1;
+i.RIG_MODE_NONE = 0;
+i.RIG_MODE_STEREOSCOPIC_ANAGLYPH = 10;
+i.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL = 11;
+i.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_CROSSEYED = 12;
+i.RIG_MODE_STEREOSCOPIC_OVERUNDER = 13;
+i.RIG_MODE_STEREOSCOPIC_INTERLACED = 14;
+i.RIG_MODE_VR = 20;
+i.RIG_MODE_WEBVR = 21;
+i.RIG_MODE_CUSTOM = 22;
+i.ForceAttachControlToAlwaysPreventDefault = !1;
+n([
+  y("position")
+], i.prototype, "_position", void 0);
+n([
+  y("upVector")
+], i.prototype, "_upVector", void 0);
+n([
+  h()
+], i.prototype, "orthoLeft", null);
+n([
+  h()
+], i.prototype, "orthoRight", null);
+n([
+  h()
+], i.prototype, "orthoBottom", null);
+n([
+  h()
+], i.prototype, "orthoTop", null);
+n([
+  h()
+], i.prototype, "fov", void 0);
+n([
+  h()
+], i.prototype, "projectionPlaneTilt", void 0);
+n([
+  h()
+], i.prototype, "minZ", void 0);
+n([
+  h()
+], i.prototype, "maxZ", void 0);
+n([
+  h()
+], i.prototype, "inertia", void 0);
+n([
+  h()
+], i.prototype, "mode", null);
+n([
+  h()
+], i.prototype, "layerMask", void 0);
+n([
+  h()
+], i.prototype, "fovMode", void 0);
+n([
+  h()
+], i.prototype, "cameraRigMode", void 0);
+n([
+  h()
+], i.prototype, "interaxialDistance", void 0);
+n([
+  h()
+], i.prototype, "isStereoscopicSideBySide", void 0);
+export {
+  i as Camera
+};