@configura/babylon-view 2.1.0-alpha.3 → 2.2.0-alpha.0

package/dist/camera/CfgOrbitalCamera.js

@@ -1,281 +1,277 @@
-import { PointerEventTypes } from "@babylonjs/core";
-import { ArcRotateCamera } from "@babylonjs/core/Cameras/arcRotateCamera.js";
-import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { degToRad, normalizeAngle, Observable } from "@configura/web-utilities";
-import { CfgBoundingBox } from "../utilities/CfgBoundingBox.js";
-import { boundingBoxesAreSignificantlyDifferent, measureLongestDistanceToCorner, } from "../utilities/utilities3D.js";
-import { CfgArcRotateCameraPointersInput } from "./CfgArcRotateCameraPointersInput.js";
-import { orbitalCameraControlPropsEquals, } from "./CfgOrbitalCameraControlProps.js";
-const NEAREST_ALLOWED_TO_BETA_LIMITS = 0.1;
-export const MAX_UPPER_BETA_LIMIT = Math.PI - NEAREST_ALLOWED_TO_BETA_LIMITS;
-export const MIN_LOWER_BETA_LIMIT = NEAREST_ALLOWED_TO_BETA_LIMITS;
-const defaultOrbitalCameraConfig = {
-    fov: degToRad(30),
-    mouseWheelSpeedFactor: 200,
-    pinchZoomFactor: 100,
-    inertia: 0.93,
-    keyboardSpeedFactor: 0.002,
-    pointerSpeedFactor: 2000,
-    keepCameraFromGettingTooCloseFactor: 1.5,
-    significantBoundingBoxSizeChangeShrinkFactor: 0.4,
-    significantBoundingBoxSizeChangeGrowFactor: 0.1,
-};
-// Babylon initializes radius to this to avoid divide by zero
-const BABYLON_DO_NOT_DIVIDE_BY_ZERO_MAGIC_CONSTANT = 0.0001;
-// This is a workaround as you are not allowed to override fields with accessors.
-// By adding this abstract field this becomes possible. This is a hack.
-class WorkaroundCfgOrbitalCamera extends ArcRotateCamera {
-}
-export class CfgOrbitalCamera extends WorkaroundCfgOrbitalCamera {
-    constructor(scene, _canvas, config) {
-        super("CfgOrbitalCamera", 0, degToRad(90), 50, new Vector3(0, 0, 0), scene);
-        this._canvas = _canvas;
-        this._currentBoundingBox = new CfgBoundingBox();
-        this._latestSignificantChangeBoundingBox = new CfgBoundingBox();
-        this._disableSubFloorCam = false;
-        this._lowestAllowedCameraHeight = undefined;
-        this._pointerDown = false;
-        this.disableAutomaticSizing = false;
-        this.disableZoom = false;
-        this._externalControlHasHappened = false;
-        this._radius = 0;
-        this._boundCameraListener = () => {
-            // This is a cheap operation, so it's acceptable to do it
-            // for every update (even if no radius-change has happened)
-            this._applyNoSneakPeeking();
-            this._notifyCameraControlListeners();
-        };
-        this._pointerUpDownCallback = (p, s) => {
-            if (p.type === PointerEventTypes.POINTERUP) {
-                this._pointerDown = false;
-                this._notifyCameraControlListeners();
-            }
-            if (p.type === PointerEventTypes.POINTERDOWN) {
-                this._pointerDown = true;
-            }
-        };
-        this.attachControl(_canvas, // This parameters is not actually used for anything. But still required.
-        false, // No panning with keyboard
-        false // No panning with mouse
-        );
-        // Workaround for touch issues on iOS, see comments in CfgArcRotateCameraPointersInput.ts
-        this.inputs.removeByType("ArcRotateCameraPointersInput");
-        this.inputs.add(new CfgArcRotateCameraPointersInput());
-        // Make sure to disable all forms of "panning", which for the ArcRotateCamera is defined
-        // as movement sideways without rotation to keep the camera centered on the target.
-        // The settings above for attachControl will not disable two-finger touch.
-        this.panningAxis = Vector3.Zero();
-        this.panningDistanceLimit = 0;
-        this.panningSensibility = 0;
-        this.panningInertia = 0;
-        this._config = Object.assign(Object.assign({}, defaultOrbitalCameraConfig), config);
-        const keyboardInput = this.inputs.attached["keyboard"];
-        keyboardInput.angularSpeed = this._config.keyboardSpeedFactor;
-        this.fov = this._config.fov;
-        this.inertia = this._config.inertia;
-        this.angularSensibilityX = this.angularSensibilityY = this._config.pointerSpeedFactor;
-        scene.onPointerObservable.add(this._pointerUpDownCallback, PointerEventTypes.POINTERUP | PointerEventTypes.POINTERDOWN);
-        this.onViewMatrixChangedObservable.add(this._boundCameraListener);
-    }
-    dispose() {
-        this.detachControl(this._canvas);
-        this.onViewMatrixChangedObservable.removeCallback(this._boundCameraListener);
-        this._scene.onPointerObservable.removeCallback(this._pointerUpDownCallback);
-        super.dispose();
-    }
-    set disableSubFloorCam(v) {
-        this._disableSubFloorCam = v;
-    }
-    set lowestAllowedCameraHeight(v) {
-        this._lowestAllowedCameraHeight = v;
-    }
-    get lowestAllowedCameraHeight() {
-        if (this._lowestAllowedCameraHeight !== undefined) {
-            if (this._disableSubFloorCam) {
-                return Math.max(0, this._lowestAllowedCameraHeight);
-            }
-            return this._lowestAllowedCameraHeight;
-        }
-        if (this._disableSubFloorCam) {
-            return 0;
-        }
-        return undefined;
-    }
-    forceRadius(r) {
-        this._radius = r;
-    }
-    set radius(r) {
-        if (this.disableZoom) {
-            return;
-        }
-        this._radius = r;
-    }
-    get radius() {
-        return this._radius;
-    }
-    get _orbitalCameraControlProps() {
-        return {
-            distance: this.radius === BABYLON_DO_NOT_DIVIDE_BY_ZERO_MAGIC_CONSTANT
-                ? undefined
-                : this.radius,
-            yaw: normalizeAngle(this.alpha),
-            pitch: this.beta,
-            distanceWasAutoSet: this.radius === this._currentMinDistanceToFitModelInView,
-            committed: !(this._isMoving || this._pointerDown),
-        };
-    }
-    frameRenderNeeded() {
-        const externalControlHasHappened = this._externalControlHasHappened;
-        if (externalControlHasHappened) {
-            this._externalControlHasHappened = false;
-        }
-        return this._isMoving || externalControlHasHappened;
-    }
-    get _isMoving() {
-        return (this.useAutoRotationBehavior ||
-            this.inertialAlphaOffset !== 0 ||
-            this.inertialBetaOffset !== 0 ||
-            this.inertialPanningX !== 0 ||
-            this.inertialPanningY !== 0 ||
-            this.inertialRadiusOffset !== 0);
-    }
-    _notifyCameraControlListeners() {
-        if (this._orbitalCameraControlObservable === undefined) {
-            return;
-        }
-        const orbitalCameraControlProps = this._orbitalCameraControlProps;
-        if (this._previousOrbitalCameraControlProps !== undefined &&
-            orbitalCameraControlPropsEquals(this._previousOrbitalCameraControlProps, orbitalCameraControlProps)) {
-            return;
-        }
-        this._orbitalCameraControlObservable.notifyAll(orbitalCameraControlProps, this._orbitalCameraControlObservable);
-        this._previousOrbitalCameraControlProps = orbitalCameraControlProps;
-    }
-    get cameraControlObservable() {
-        if (this._orbitalCameraControlObservable === undefined) {
-            this._orbitalCameraControlObservable = new Observable();
-            this._orbitalCameraControlObservable.listen((c) => {
-                const { distance, yaw, pitch, distanceWasAutoSet } = c;
-                let change = false;
-                if (distanceWasAutoSet !== true &&
-                    distance !== undefined &&
-                    distance !== this.radius) {
-                    this.forceRadius(distance);
-                    change = true;
-                }
-                if (yaw !== undefined && yaw !== this.alpha) {
-                    this.alpha = yaw;
-                    change = true;
-                }
-                if (pitch !== undefined && pitch !== this.beta) {
-                    this.beta = pitch;
-                    change = true;
-                }
-                if (change) {
-                    this._externalControlHasHappened = true;
-                    this._notifyCameraControlListeners();
-                }
-            }, this._orbitalCameraControlObservable);
-        }
-        return this._orbitalCameraControlObservable;
-    }
-    /**
-     * @param force true makes the camera distance adapt to the new bounds, even if they have
-     * not changed significantly. false makes the camera distance not adapt even if the
-     * bounding box size change is significant.
-     */
-    setContentBoundingBox(newBoundingBox, force) {
-        this._currentBoundingBox = newBoundingBox;
-        const significantChange = boundingBoxesAreSignificantlyDifferent(this._latestSignificantChangeBoundingBox, newBoundingBox, this._config.significantBoundingBoxSizeChangeShrinkFactor, this._config.significantBoundingBoxSizeChangeGrowFactor);
-        if (!significantChange && force !== true) {
-            return;
-        }
-        this._latestSignificantChangeBoundingBox = newBoundingBox;
-        this._applyAdaptToContentBoundingBox(force);
-        this._applyNoSneakPeeking();
-    }
-    _applyAdaptToContentBoundingBox(force) {
-        const bb = this._currentBoundingBox;
-        if (bb.isEmpty) {
-            return;
-        }
-        // Keeps the camera from recomputing angles and distance
-        const pre = [this.alpha, this.beta, this.radius];
-        this.target = bb.center;
-        if (this.disableAutomaticSizing) {
-            return;
-        }
-        [this.alpha, this.beta, this.radius] = pre;
-        this._updateCameraLimits();
-        const minDistanceToFitModelInView = this._currentMinDistanceToFitModelInView;
-        const minDistanceToKeepCameraOutOfModel = this._currentMinDistanceToKeepCameraOutOfModel;
-        if (minDistanceToFitModelInView !== undefined) {
-            if (force !== false && (force === true || this.radius < minDistanceToFitModelInView)) {
-                this.forceRadius(minDistanceToFitModelInView);
-            }
-        }
-        if (minDistanceToKeepCameraOutOfModel !== undefined &&
-            minDistanceToFitModelInView !== undefined) {
-            this.lowerRadiusLimit =
-                minDistanceToKeepCameraOutOfModel *
-                    this._config.keepCameraFromGettingTooCloseFactor;
-            this.upperRadiusLimit = minDistanceToFitModelInView * 2;
-            this.wheelPrecision =
-                this._config.mouseWheelSpeedFactor / minDistanceToKeepCameraOutOfModel;
-            this.pinchPrecision = this._config.pinchZoomFactor / minDistanceToKeepCameraOutOfModel;
-            this.speed = minDistanceToKeepCameraOutOfModel * 0.1;
-        }
-    }
-    refreshCameraNearFar() {
-        const minDistanceToKeepCameraOutOfModel = this._currentMinDistanceToKeepCameraOutOfModel;
-        if (minDistanceToKeepCameraOutOfModel === undefined) {
-            return;
-        }
-        const cameraDistance = this.radius;
-        const extraSpaceFactor = 1.5; // Because when zooming fast it seems the limits do not keep up
-        const graceDistance = minDistanceToKeepCameraOutOfModel * extraSpaceFactor;
-        this.minZ = cameraDistance - graceDistance;
-        this.maxZ = cameraDistance + graceDistance;
-    }
-    _applyNoSneakPeeking() {
-        //It might be impolite to look at a Cfg models underside
-        const noPeekLimit = this._calculateNoPeekingLimit();
-        if (noPeekLimit === undefined || !isFinite(noPeekLimit)) {
-            this.upperBetaLimit = MAX_UPPER_BETA_LIMIT;
-            return;
-        }
-        this.upperBetaLimit = Math.min(MAX_UPPER_BETA_LIMIT, Math.PI / 2 - noPeekLimit);
-    }
-    _updateCameraLimits() {
-        const bb = this._currentBoundingBox;
-        const fovVertical = this.fov;
-        const aspect = this.getEngine().getScreenAspectRatio();
-        const bbAdjustedForCameraPosition = bb.clone().translate(this.target.negate());
-        const longestDistanceToCornerInXYZSpace = measureLongestDistanceToCorner(bbAdjustedForCameraPosition, [0, 1, 2]);
-        const longestDistanceToCornerInXZPlane = measureLongestDistanceToCorner(bbAdjustedForCameraPosition, [0, 2]);
-        const fovHorizontalRad = 2 * Math.atan(Math.tan(fovVertical / 2) * aspect);
-        const maxAllowedHeight = longestDistanceToCornerInXYZSpace * 2;
-        const maxAllowedWidth = longestDistanceToCornerInXZPlane * 2; //Because the model can not be tilted, only spun
-        const minDistanceToFitInViewFromWidth = maxAllowedWidth / (2 * Math.tan(fovHorizontalRad / 2));
-        const minDistanceToFitInViewFromHeight = maxAllowedHeight / (2 * Math.tan(fovVertical / 2));
-        const minDistanceToFitModelInView = Math.max(minDistanceToFitInViewFromWidth, minDistanceToFitInViewFromHeight);
-        this._currentMinDistanceToKeepCameraOutOfModel = isFinite(longestDistanceToCornerInXYZSpace)
-            ? longestDistanceToCornerInXYZSpace
-            : undefined;
-        this._currentMinDistanceToFitModelInView = isFinite(minDistanceToFitModelInView)
-            ? minDistanceToFitModelInView
-            : undefined;
-    }
-    _calculateNoPeekingLimit() {
-        const bb = this._currentBoundingBox;
-        if (bb.isEmpty || this.lowestAllowedCameraHeight === undefined) {
-            return undefined;
-        }
-        const bottomDepth = bb.minimum.y -
-            this.target.y +
-            (bb.maximum.y - bb.minimum.y) * this.lowestAllowedCameraHeight;
-        const cameraDistance = this.radius;
-        const lowestAngleUnderHorizonRad = Math.asin(bottomDepth / cameraDistance);
-        return lowestAngleUnderHorizonRad;
-    }
-}
+import { PointerEventTypes } from "@babylonjs/core";
+import { ArcRotateCamera } from "@babylonjs/core/Cameras/arcRotateCamera.js";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { degToRad, normalizeAngle, Observable } from "@configura/web-utilities";
+import { CfgBoundingBox } from "../utilities/CfgBoundingBox.js";
+import { boundingBoxesAreSignificantlyDifferent, measureLongestDistanceToCorner, } from "../utilities/utilities3D.js";
+import { orbitalCameraControlPropsEquals, } from "./CfgOrbitalCameraControlProps.js";
+const NEAREST_ALLOWED_TO_BETA_LIMITS = 0.1;
+export const MAX_UPPER_BETA_LIMIT = Math.PI - NEAREST_ALLOWED_TO_BETA_LIMITS;
+export const MIN_LOWER_BETA_LIMIT = NEAREST_ALLOWED_TO_BETA_LIMITS;
+const defaultOrbitalCameraConfig = {
+    fov: degToRad(30),
+    mouseWheelSpeedFactor: 200,
+    pinchZoomFactor: 100,
+    inertia: 0.93,
+    keyboardSpeedFactor: 0.002,
+    pointerSpeedFactor: 2000,
+    keepCameraFromGettingTooCloseFactor: 1.5,
+    significantBoundingBoxSizeChangeShrinkFactor: 0.4,
+    significantBoundingBoxSizeChangeGrowFactor: 0.1,
+};
+// Babylon initializes radius to this to avoid divide by zero
+const BABYLON_DO_NOT_DIVIDE_BY_ZERO_MAGIC_CONSTANT = 0.0001;
+// This is a workaround as you are not allowed to override fields with accessors.
+// By adding this abstract field this becomes possible. This is a hack.
+class WorkaroundCfgOrbitalCamera extends ArcRotateCamera {
+}
+export class CfgOrbitalCamera extends WorkaroundCfgOrbitalCamera {
+    constructor(scene, _canvas, config) {
+        super("CfgOrbitalCamera", 0, degToRad(90), 50, new Vector3(0, 0, 0), scene);
+        this._canvas = _canvas;
+        this._currentBoundingBox = new CfgBoundingBox();
+        this._latestSignificantChangeBoundingBox = new CfgBoundingBox();
+        this._disableSubFloorCam = false;
+        this._lowestAllowedCameraHeight = undefined;
+        this._pointerDown = false;
+        this.disableAutomaticSizing = false;
+        this.disableZoom = false;
+        this._externalControlHasHappened = false;
+        this._radius = 0;
+        this._boundCameraListener = () => {
+            // This is a cheap operation, so it's acceptable to do it
+            // for every update (even if no radius-change has happened)
+            this._applyNoSneakPeeking();
+            this._notifyCameraControlListeners();
+        };
+        this._pointerUpDownCallback = (p, s) => {
+            if (p.type === PointerEventTypes.POINTERUP) {
+                this._pointerDown = false;
+                this._notifyCameraControlListeners();
+            }
+            if (p.type === PointerEventTypes.POINTERDOWN) {
+                this._pointerDown = true;
+            }
+        };
+        this.attachControl(_canvas, // This parameters is not actually used for anything. But still required.
+        false, // No panning with keyboard
+        false // No panning with mouse
+        );
+        // Make sure to disable all forms of "panning", which for the ArcRotateCamera is defined
+        // as movement sideways without rotation to keep the camera centered on the target.
+        // The settings above for attachControl will not disable two-finger touch.
+        this.panningAxis = Vector3.Zero();
+        this.panningDistanceLimit = 0;
+        this.panningSensibility = 0;
+        this.panningInertia = 0;
+        this._config = Object.assign(Object.assign({}, defaultOrbitalCameraConfig), config);
+        const keyboardInput = this.inputs.attached["keyboard"];
+        keyboardInput.angularSpeed = this._config.keyboardSpeedFactor;
+        this.fov = this._config.fov;
+        this.inertia = this._config.inertia;
+        this.angularSensibilityX = this.angularSensibilityY = this._config.pointerSpeedFactor;
+        scene.onPointerObservable.add(this._pointerUpDownCallback, PointerEventTypes.POINTERUP | PointerEventTypes.POINTERDOWN);
+        this.onViewMatrixChangedObservable.add(this._boundCameraListener);
+    }
+    dispose() {
+        this.detachControl();
+        this.onViewMatrixChangedObservable.removeCallback(this._boundCameraListener);
+        this._scene.onPointerObservable.removeCallback(this._pointerUpDownCallback);
+        super.dispose();
+    }
+    set disableSubFloorCam(v) {
+        this._disableSubFloorCam = v;
+    }
+    set lowestAllowedCameraHeight(v) {
+        this._lowestAllowedCameraHeight = v;
+    }
+    get lowestAllowedCameraHeight() {
+        if (this._lowestAllowedCameraHeight !== undefined) {
+            if (this._disableSubFloorCam) {
+                return Math.max(0, this._lowestAllowedCameraHeight);
+            }
+            return this._lowestAllowedCameraHeight;
+        }
+        if (this._disableSubFloorCam) {
+            return 0;
+        }
+        return undefined;
+    }
+    forceRadius(r) {
+        this._radius = r;
+    }
+    set radius(r) {
+        if (this.disableZoom) {
+            return;
+        }
+        this._radius = r;
+    }
+    get radius() {
+        return this._radius;
+    }
+    get _orbitalCameraControlProps() {
+        return {
+            distance: this.radius === BABYLON_DO_NOT_DIVIDE_BY_ZERO_MAGIC_CONSTANT
+                ? undefined
+                : this.radius,
+            yaw: normalizeAngle(this.alpha),
+            pitch: this.beta,
+            distanceWasAutoSet: this.radius === this._currentMinDistanceToFitModelInView,
+            committed: !(this._isMoving || this._pointerDown),
+        };
+    }
+    frameRenderNeeded() {
+        const externalControlHasHappened = this._externalControlHasHappened;
+        if (externalControlHasHappened) {
+            this._externalControlHasHappened = false;
+        }
+        return this._isMoving || externalControlHasHappened;
+    }
+    get _isMoving() {
+        return (this.useAutoRotationBehavior ||
+            this.inertialAlphaOffset !== 0 ||
+            this.inertialBetaOffset !== 0 ||
+            this.inertialPanningX !== 0 ||
+            this.inertialPanningY !== 0 ||
+            this.inertialRadiusOffset !== 0);
+    }
+    _notifyCameraControlListeners() {
+        if (this._orbitalCameraControlObservable === undefined) {
+            return;
+        }
+        const orbitalCameraControlProps = this._orbitalCameraControlProps;
+        if (this._previousOrbitalCameraControlProps !== undefined &&
+            orbitalCameraControlPropsEquals(this._previousOrbitalCameraControlProps, orbitalCameraControlProps)) {
+            return;
+        }
+        this._orbitalCameraControlObservable.notifyAll(orbitalCameraControlProps, this._orbitalCameraControlObservable);
+        this._previousOrbitalCameraControlProps = orbitalCameraControlProps;
+    }
+    get cameraControlObservable() {
+        if (this._orbitalCameraControlObservable === undefined) {
+            this._orbitalCameraControlObservable = new Observable();
+            this._orbitalCameraControlObservable.listen((c) => {
+                const { distance, yaw, pitch, distanceWasAutoSet } = c;
+                let change = false;
+                if (distanceWasAutoSet !== true &&
+                    distance !== undefined &&
+                    distance !== this.radius) {
+                    this.forceRadius(distance);
+                    change = true;
+                }
+                if (yaw !== undefined && yaw !== this.alpha) {
+                    this.alpha = yaw;
+                    change = true;
+                }
+                if (pitch !== undefined && pitch !== this.beta) {
+                    this.beta = pitch;
+                    change = true;
+                }
+                if (change) {
+                    this._externalControlHasHappened = true;
+                    this._notifyCameraControlListeners();
+                }
+            }, this._orbitalCameraControlObservable);
+        }
+        return this._orbitalCameraControlObservable;
+    }
+    /**
+     * @param force true makes the camera distance adapt to the new bounds, even if they have
+     * not changed significantly. false makes the camera distance not adapt even if the
+     * bounding box size change is significant.
+     */
+    setContentBoundingBox(newBoundingBox, force) {
+        this._currentBoundingBox = newBoundingBox;
+        const significantChange = boundingBoxesAreSignificantlyDifferent(this._latestSignificantChangeBoundingBox, newBoundingBox, this._config.significantBoundingBoxSizeChangeShrinkFactor, this._config.significantBoundingBoxSizeChangeGrowFactor);
+        if (!significantChange && force !== true) {
+            return;
+        }
+        this._latestSignificantChangeBoundingBox = newBoundingBox;
+        this._applyAdaptToContentBoundingBox(force);
+        this._applyNoSneakPeeking();
+    }
+    _applyAdaptToContentBoundingBox(force) {
+        const bb = this._currentBoundingBox;
+        if (bb.isEmpty) {
+            return;
+        }
+        // Keeps the camera from recomputing angles and distance
+        const pre = [this.alpha, this.beta, this.radius];
+        this.target = bb.center;
+        if (this.disableAutomaticSizing) {
+            return;
+        }
+        [this.alpha, this.beta, this.radius] = pre;
+        this._updateCameraLimits();
+        const minDistanceToFitModelInView = this._currentMinDistanceToFitModelInView;
+        const minDistanceToKeepCameraOutOfModel = this._currentMinDistanceToKeepCameraOutOfModel;
+        if (minDistanceToFitModelInView !== undefined) {
+            if (force !== false && (force === true || this.radius < minDistanceToFitModelInView)) {
+                this.forceRadius(minDistanceToFitModelInView);
+            }
+        }
+        if (minDistanceToKeepCameraOutOfModel !== undefined &&
+            minDistanceToFitModelInView !== undefined) {
+            this.lowerRadiusLimit =
+                minDistanceToKeepCameraOutOfModel *
+                    this._config.keepCameraFromGettingTooCloseFactor;
+            this.upperRadiusLimit = minDistanceToFitModelInView * 2;
+            this.wheelPrecision =
+                this._config.mouseWheelSpeedFactor / minDistanceToKeepCameraOutOfModel;
+            this.pinchPrecision = this._config.pinchZoomFactor / minDistanceToKeepCameraOutOfModel;
+            this.speed = minDistanceToKeepCameraOutOfModel * 0.1;
+        }
+    }
+    refreshCameraNearFar() {
+        const minDistanceToKeepCameraOutOfModel = this._currentMinDistanceToKeepCameraOutOfModel;
+        if (minDistanceToKeepCameraOutOfModel === undefined) {
+            return;
+        }
+        const cameraDistance = this.radius;
+        const extraSpaceFactor = 1.5; // Because when zooming fast it seems the limits do not keep up
+        const graceDistance = minDistanceToKeepCameraOutOfModel * extraSpaceFactor;
+        this.minZ = cameraDistance - graceDistance;
+        this.maxZ = cameraDistance + graceDistance;
+    }
+    _applyNoSneakPeeking() {
+        //It might be impolite to look at a Cfg models underside
+        const noPeekLimit = this._calculateNoPeekingLimit();
+        if (noPeekLimit === undefined || !isFinite(noPeekLimit)) {
+            this.upperBetaLimit = MAX_UPPER_BETA_LIMIT;
+            return;
+        }
+        this.upperBetaLimit = Math.min(MAX_UPPER_BETA_LIMIT, Math.PI / 2 - noPeekLimit);
+    }
+    _updateCameraLimits() {
+        const bb = this._currentBoundingBox;
+        const fovVertical = this.fov;
+        const aspect = this.getEngine().getScreenAspectRatio();
+        const bbAdjustedForCameraPosition = bb.clone().translate(this.target.negate());
+        const longestDistanceToCornerInXYZSpace = measureLongestDistanceToCorner(bbAdjustedForCameraPosition, [0, 1, 2]);
+        const longestDistanceToCornerInXZPlane = measureLongestDistanceToCorner(bbAdjustedForCameraPosition, [0, 2]);
+        const fovHorizontalRad = 2 * Math.atan(Math.tan(fovVertical / 2) * aspect);
+        const maxAllowedHeight = longestDistanceToCornerInXYZSpace * 2;
+        const maxAllowedWidth = longestDistanceToCornerInXZPlane * 2; //Because the model can not be tilted, only spun
+        const minDistanceToFitInViewFromWidth = maxAllowedWidth / (2 * Math.tan(fovHorizontalRad / 2));
+        const minDistanceToFitInViewFromHeight = maxAllowedHeight / (2 * Math.tan(fovVertical / 2));
+        const minDistanceToFitModelInView = Math.max(minDistanceToFitInViewFromWidth, minDistanceToFitInViewFromHeight);
+        this._currentMinDistanceToKeepCameraOutOfModel = isFinite(longestDistanceToCornerInXYZSpace)
+            ? longestDistanceToCornerInXYZSpace
+            : undefined;
+        this._currentMinDistanceToFitModelInView = isFinite(minDistanceToFitModelInView)
+            ? minDistanceToFitModelInView
+            : undefined;
+    }
+    _calculateNoPeekingLimit() {
+        const bb = this._currentBoundingBox;
+        if (bb.isEmpty || this.lowestAllowedCameraHeight === undefined) {
+            return undefined;
+        }
+        const bottomDepth = bb.minimum.y -
+            this.target.y +
+            (bb.maximum.y - bb.minimum.y) * this.lowestAllowedCameraHeight;
+        const cameraDistance = this.radius;
+        const lowestAngleUnderHorizonRad = Math.asin(bottomDepth / cameraDistance);
+        return lowestAngleUnderHorizonRad;
+    }
+}

package/dist/camera/CfgOrbitalCameraControlProps.d.ts

@@ -1,15 +1,15 @@
-export interface CfgOrbitalCameraBasicProps {
-    distance?: number;
-    yaw?: number;
-    pitch?: number;
-}
-/**
- * @param distanceWasAutoSet Indicates that the camera distance was auto set. If true when setting
- * camera settings @param distance will be ignored.
- */
-export interface CfgOrbitalCameraControlProps extends CfgOrbitalCameraBasicProps {
-    distanceWasAutoSet?: boolean;
-    committed?: boolean;
-}
-export declare function orbitalCameraControlPropsEquals(left: CfgOrbitalCameraControlProps, right: CfgOrbitalCameraControlProps, ignoreCommitted?: boolean): boolean;
+export interface CfgOrbitalCameraBasicProps {
+    distance?: number;
+    yaw?: number;
+    pitch?: number;
+}
+/**
+ * @param distanceWasAutoSet Indicates that the camera distance was auto set. If true when setting
+ * camera settings @param distance will be ignored.
+ */
+export interface CfgOrbitalCameraControlProps extends CfgOrbitalCameraBasicProps {
+    distanceWasAutoSet?: boolean;
+    committed?: boolean;
+}
+export declare function orbitalCameraControlPropsEquals(left: CfgOrbitalCameraControlProps, right: CfgOrbitalCameraControlProps, ignoreCommitted?: boolean): boolean;
 //# sourceMappingURL=CfgOrbitalCameraControlProps.d.ts.map

package/dist/camera/CfgOrbitalCameraControlProps.js

@@ -1,7 +1,7 @@
-export function orbitalCameraControlPropsEquals(left, right, ignoreCommitted = false) {
-    return (((left.distanceWasAutoSet && right.distanceWasAutoSet) ||
-        left.distance === right.distance) &&
-        left.yaw === right.yaw &&
-        left.pitch === right.pitch &&
-        (ignoreCommitted || left.committed === right.committed));
-}
+export function orbitalCameraControlPropsEquals(left, right, ignoreCommitted = false) {
+    return (((left.distanceWasAutoSet && right.distanceWasAutoSet) ||
+        left.distance === right.distance) &&
+        left.yaw === right.yaw &&
+        left.pitch === right.pitch &&
+        (ignoreCommitted || left.committed === right.committed));
+}

package/dist/camera/GradingApplier.d.ts

@@ -1,4 +1,4 @@
-import { Camera } from "@babylonjs/core/Cameras/camera.js";
-export declare type GradingApplier = (camera: Camera) => void;
-export declare const getDefaultGradingApplier: () => GradingApplier;
+import { Camera } from "@babylonjs/core/Cameras/camera.js";
+export declare type GradingApplier = (camera: Camera) => void;
+export declare const getDefaultGradingApplier: () => GradingApplier;
 //# sourceMappingURL=GradingApplier.d.ts.map