@onerjs/core 8.30.9 → 8.31.1

package/Cameras/Inputs/geospatialCameraPointersInput.d.ts

@@ -2,11 +2,11 @@ import type { GeospatialCamera } from "../../Cameras/geospatialCamera.js";
 import type { IPointerEvent } from "../../Events/deviceInputEvents.js";
 import type { PointerTouch } from "../../Events/pointerEvents.js";
 import type { Nullable } from "../../types.js";
-import { BaseCameraPointersInput } from "./BaseCameraPointersInput.js";
+import { OrbitCameraPointersInput } from "./orbitCameraPointersInput.js";
 /**
  * @experimental
  * Geospatial camera inputs can simulate dragging the globe around or tilting the camera around some point on the globe
- * The input will update the camera's localTranslation or localRotation values, and the camera is responsible for using these updates to calculate viewMatrix appropriately
+ * This class will update the GeospatialCameraMovement class's movementDeltaCurrentFrame, and the camera is responsible for using these updates to calculate viewMatrix appropriately
  *
  * As of right now, the camera correction logic (to keep the camera geospatially oriented around the globe) is happening within the camera class when calculating viewmatrix
  * As this is experimental, it is possible we move that correction step to live within the input class (to enable non-corrected translations in the future), say if we want to allow the camera to move outside of the globe's orbit
@@ -16,30 +16,25 @@ import { BaseCameraPointersInput } from "./BaseCameraPointersInput.js";
  * Right mouse button: tilt globe around center of screen
  *
  */
-export declare class GeospatialCameraPointersInput extends BaseCameraPointersInput {
+export declare class GeospatialCameraPointersInput extends OrbitCameraPointersInput {
     camera: GeospatialCamera;
-    /**
-     * Mouse sensitivity for rotation (lower = more sensitive)
-     */
-    angularSensibility: number;
-    private _dragPlane;
-    private _dragPlaneNormal;
-    private _dragPlaneOriginPoint;
-    private _dragPlaneHitPoint;
-    private _dragPlaneOffsetVector;
-    private _hitPointRadius?;
     getClassName(): string;
     onButtonDown(evt: IPointerEvent): void;
     onTouch(point: Nullable<PointerTouch>, offsetX: number, offsetY: number): void;
-    onButtonUp(_evt: IPointerEvent): void;
     /**
-     * The DragPlaneOffsetVector represents the vector between the dragPlane hit point and the dragPlane origin point.
-     * As the drag movement occurs, we will continuously recalculate this vector. The delta between the offsetVectors is the delta we will apply to the camera's localtranslation
-     * @param hitPointRadius The distance between the world origin (center of globe) and the initial drag hit point
-     * @param ray The ray from the camera to the new cursor location
-     * @param ref The offset vector between the drag plane's hitPoint and originPoint
+     * Move camera from multitouch (pinch) zoom distances.
+     * @param previousPinchSquaredDistance
+     * @param pinchSquaredDistance
      */
-    private _recalculateDragPlaneOffsetVectorToRef;
-    private _handleDrag;
+    protected _computePinchZoom(previousPinchSquaredDistance: number, pinchSquaredDistance: number): void;
+    /**
+     * Move camera from multi touch panning positions.
+     * In geospatialcamera, multi touch panning tilts the globe (whereas single touch will pan/drag it)
+     * @param previousMultiTouchPanPosition
+     * @param multiTouchPanPosition
+     */
+    protected _computeMultiTouchPanning(previousMultiTouchPanPosition: Nullable<PointerTouch>, multiTouchPanPosition: Nullable<PointerTouch>): void;
+    onMultiTouch(pointA: Nullable<PointerTouch>, pointB: Nullable<PointerTouch>, previousPinchSquaredDistance: number, pinchSquaredDistance: number, previousMultiTouchPanPosition: Nullable<PointerTouch>, multiTouchPanPosition: Nullable<PointerTouch>): void;
+    onButtonUp(_evt: IPointerEvent): void;
     private _handleTilt;
 }

package/Cameras/Inputs/geospatialCameraPointersInput.js

@@ -1,10 +1,8 @@
-import { Plane } from "../../Maths/math.plane.js";
-import { TmpVectors, Vector3 } from "../../Maths/math.vector.js";
-import { BaseCameraPointersInput } from "./BaseCameraPointersInput.js";
+import { OrbitCameraPointersInput } from "./orbitCameraPointersInput.js";
 /**
  * @experimental
  * Geospatial camera inputs can simulate dragging the globe around or tilting the camera around some point on the globe
- * The input will update the camera's localTranslation or localRotation values, and the camera is responsible for using these updates to calculate viewMatrix appropriately
+ * This class will update the GeospatialCameraMovement class's movementDeltaCurrentFrame, and the camera is responsible for using these updates to calculate viewMatrix appropriately
  *
  * As of right now, the camera correction logic (to keep the camera geospatially oriented around the globe) is happening within the camera class when calculating viewmatrix
  * As this is experimental, it is possible we move that correction step to live within the input class (to enable non-corrected translations in the future), say if we want to allow the camera to move outside of the globe's orbit
@@ -14,106 +12,78 @@ import { BaseCameraPointersInput } from "./BaseCameraPointersInput.js";
  * Right mouse button: tilt globe around center of screen
  *
  */
-export class GeospatialCameraPointersInput extends BaseCameraPointersInput {
-    constructor() {
-        super(...arguments);
-        /**
-         * Mouse sensitivity for rotation (lower = more sensitive)
-         */
-        this.angularSensibility = 200.0;
-        this._dragPlane = new Plane(0, 0, 0, 0);
-        this._dragPlaneNormal = Vector3.Zero();
-        this._dragPlaneOriginPoint = Vector3.Zero();
-        this._dragPlaneHitPoint = Vector3.Zero();
-        this._dragPlaneOffsetVector = Vector3.Zero();
-    }
+export class GeospatialCameraPointersInput extends OrbitCameraPointersInput {
     getClassName() {
         return "GeospatialCameraPointersInput";
     }
     onButtonDown(evt) {
+        this.camera.movement.activeInput = true;
         const scene = this.camera.getScene();
         let pickResult;
         switch (evt.button) {
             case 0: // Left button - drag/pan globe under cursor
-                pickResult = scene.pick(scene.pointerX, scene.pointerY, this.camera.pickPredicate);
-                if (pickResult.pickedPoint && pickResult.ray) {
-                    // Store radius from earth center to pickedPoint, used when calculating drag plane
-                    this._hitPointRadius = pickResult.pickedPoint.length();
-                    // The dragPlaneOffsetVector will later be recalculated when drag occurs, and the delta between the offset vectors will be applied to localTranslation
-                    this._recalculateDragPlaneOffsetVectorToRef(this._hitPointRadius, pickResult.ray, this._dragPlaneOffsetVector);
-                }
-                else {
-                    this._hitPointRadius = undefined; // can't drag without a hit on the globe
-                }
+                this.camera.movement.startDrag(scene.pointerX, scene.pointerY);
                 break;
             case 1: // Middle button - tilt camera around cursor
                 pickResult = scene.pick(scene.pointerX, scene.pointerY, this.camera.pickPredicate);
-                pickResult.pickedPoint && (this.camera._alternateRotationPt = pickResult.pickedPoint);
+                pickResult.pickedPoint && (this.camera.movement.alternateRotationPt = pickResult.pickedPoint);
                 break;
             case 2: // Right button - tilt camera around center of screen, already the default
-                this.camera._alternateRotationPt = this.camera.center;
+                this.camera.movement.alternateRotationPt = this.camera.center;
                 break;
             default:
                 return;
         }
     }
     onTouch(point, offsetX, offsetY) {
-        switch (point?.button) {
-            case 0: // Left button - drag/pan globe under cursor
-                this._hitPointRadius !== undefined && this._handleDrag(this._hitPointRadius);
+        // Single finger touch (no button property) or left button (button 0) = drag
+        const button = point?.button ?? 0; // Default to button 0 (drag) if undefined
+        const scene = this.camera.getScene();
+        switch (button) {
+            case 0: // Left button / single touch - drag/pan globe under cursor
+                this.camera.movement.handleDrag(scene.pointerX, scene.pointerY);
                 break;
-            case 1: // Middle button - tilt camera around cursor
+            case 1: // Middle button - tilt camera
             case 2: // Right button - tilt camera
                 this._handleTilt(offsetX, offsetY);
                 break;
         }
     }
-    onButtonUp(_evt) {
-        this._hitPointRadius = undefined;
-        this.camera._alternateRotationPt = null;
-    }
     /**
-     * The DragPlaneOffsetVector represents the vector between the dragPlane hit point and the dragPlane origin point.
-     * As the drag movement occurs, we will continuously recalculate this vector. The delta between the offsetVectors is the delta we will apply to the camera's localtranslation
-     * @param hitPointRadius The distance between the world origin (center of globe) and the initial drag hit point
-     * @param ray The ray from the camera to the new cursor location
-     * @param ref The offset vector between the drag plane's hitPoint and originPoint
+     * Move camera from multitouch (pinch) zoom distances.
+     * @param previousPinchSquaredDistance
+     * @param pinchSquaredDistance
      */
-    _recalculateDragPlaneOffsetVectorToRef(hitPointRadius, ray, ref) {
-        // Use the camera's geocentric normal to find the dragPlaneOriginPoint which lives at hitPointRadius along the camera's geocentric normal
-        this.camera.position.normalizeToRef(this._dragPlaneNormal);
-        this._dragPlaneNormal.scaleToRef(hitPointRadius, this._dragPlaneOriginPoint);
-        // Now create a plane at that point, perpendicular to the camera's geocentric normal
-        Plane.FromPositionAndNormalToRef(this._dragPlaneOriginPoint, this._dragPlaneNormal, this._dragPlane);
-        // Lastly, find the _dragPlaneHitPoint where the ray intersects the _dragPlane
-        IntersectRayWithPlaneToRef(ray, this._dragPlane, this._dragPlaneHitPoint);
-        // Store the new offset between the drag plane's hitPoint and originPoint
-        this._dragPlaneHitPoint.subtractToRef(this._dragPlaneOriginPoint, ref);
+    _computePinchZoom(previousPinchSquaredDistance, pinchSquaredDistance) {
+        this.camera.radius = (this.camera.radius * Math.sqrt(previousPinchSquaredDistance)) / Math.sqrt(pinchSquaredDistance);
     }
-    _handleDrag(hitPointRadius) {
-        const scene = this.camera.getScene();
-        const pickResult = scene.pick(scene.pointerX, scene.pointerY);
-        if (pickResult.ray) {
-            const newDragPlaneOffsetVector = TmpVectors.Vector3[5];
-            this._recalculateDragPlaneOffsetVectorToRef(hitPointRadius, pickResult.ray, newDragPlaneOffsetVector);
-            const delta = TmpVectors.Vector3[6];
-            newDragPlaneOffsetVector.subtractToRef(this._dragPlaneOffsetVector, delta);
-            this._dragPlaneOffsetVector.copyFrom(newDragPlaneOffsetVector);
-            this.camera._perFrameGeocentricTranslation.subtractInPlace(delta); // ???
+    /**
+     * Move camera from multi touch panning positions.
+     * In geospatialcamera, multi touch panning tilts the globe (whereas single touch will pan/drag it)
+     * @param previousMultiTouchPanPosition
+     * @param multiTouchPanPosition
+     */
+    _computeMultiTouchPanning(previousMultiTouchPanPosition, multiTouchPanPosition) {
+        if (previousMultiTouchPanPosition && multiTouchPanPosition) {
+            const moveDeltaX = multiTouchPanPosition.x - previousMultiTouchPanPosition.x;
+            const moveDeltaY = multiTouchPanPosition.y - previousMultiTouchPanPosition.y;
+            this._handleTilt(moveDeltaX, moveDeltaY);
         }
     }
-    _handleTilt(deltaX, deltaY) {
-        this.camera._perFrameGeocentricRotation.y += -deltaX / this.angularSensibility; // yaw - looking side to side
-        this.camera._perFrameGeocentricRotation.x += -deltaY / this.angularSensibility; // pitch - look up towards sky / down towards ground
+    onMultiTouch(pointA, pointB, previousPinchSquaredDistance, pinchSquaredDistance, previousMultiTouchPanPosition, multiTouchPanPosition) {
+        this._shouldStartPinchZoom =
+            this._twoFingerActivityCount < 20 && Math.abs(Math.sqrt(pinchSquaredDistance) - Math.sqrt(previousPinchSquaredDistance)) > this.camera.limits.pinchToPanMax;
+        super.onMultiTouch(pointA, pointB, previousPinchSquaredDistance, pinchSquaredDistance, previousMultiTouchPanPosition, multiTouchPanPosition);
     }
-}
-function IntersectRayWithPlaneToRef(ray, plane, ref) {
-    // Distance along the ray to the plane; null if no hit
-    const dist = ray.intersectsPlane(plane);
-    if (dist !== null && dist >= 0) {
-        ray.origin.addToRef(ray.direction.scaleToRef(dist, TmpVectors.Vector3[0]), ref);
-        return true;
+    onButtonUp(_evt) {
+        this.camera.movement.stopDrag();
+        this.camera.movement.alternateRotationPt = undefined;
+        this.camera.movement.activeInput = false;
+        super.onButtonUp(_evt);
+    }
+    _handleTilt(deltaX, deltaY) {
+        this.camera.movement.rotationAccumulatedPixels.y -= deltaX; // yaw - looking side to side
+        this.camera.movement.rotationAccumulatedPixels.x -= deltaY; // pitch - look up towards sky / down towards ground
     }
-    return false;
 }
 //# sourceMappingURL=geospatialCameraPointersInput.js.map

package/Cameras/Inputs/geospatialCameraPointersInput.js.map

@@ -1 +1 @@
-{"version":3,"file":"geospatialCameraPointersInput.js","sourceRoot":"","sources":["../../../../../dev/core/src/Cameras/Inputs/geospatialCameraPointersInput.ts"],"names":[],"mappings":"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","sourcesContent":["import type { GeospatialCamera } from \"../../Cameras/geospatialCamera\";\r\nimport type { PickingInfo } from \"../../Collisions/pickingInfo\";\r\nimport type { Ray } from \"../../Culling/ray\";\r\nimport type { IPointerEvent } from \"../../Events/deviceInputEvents\";\r\nimport type { PointerTouch } from \"../../Events/pointerEvents\";\r\nimport { Plane } from \"../../Maths/math.plane\";\r\nimport { TmpVectors, Vector3 } from \"../../Maths/math.vector\";\r\nimport type { Nullable } from \"../../types\";\r\nimport { BaseCameraPointersInput } from \"./BaseCameraPointersInput\";\r\n\r\n/**\r\n * @experimental\r\n * Geospatial camera inputs can simulate dragging the globe around or tilting the camera around some point on the globe\r\n * The input will update the camera's localTranslation or localRotation values, and the camera is responsible for using these updates to calculate viewMatrix appropriately\r\n *\r\n * As of right now, the camera correction logic (to keep the camera geospatially oriented around the globe) is happening within the camera class when calculating viewmatrix\r\n * As this is experimental, it is possible we move that correction step to live within the input class (to enable non-corrected translations in the future), say if we want to allow the camera to move outside of the globe's orbit\r\n *\r\n * Left mouse button: drag globe\r\n * Middle mouse button: tilt globe around cursor location\r\n * Right mouse button: tilt globe around center of screen\r\n *\r\n */\r\nexport class GeospatialCameraPointersInput extends BaseCameraPointersInput {\r\n    public camera: GeospatialCamera;\r\n\r\n    /**\r\n     * Mouse sensitivity for rotation (lower = more sensitive)\r\n     */\r\n    public angularSensibility = 200.0;\r\n\r\n    private _dragPlane: Plane = new Plane(0, 0, 0, 0);\r\n    private _dragPlaneNormal: Vector3 = Vector3.Zero();\r\n    private _dragPlaneOriginPoint: Vector3 = Vector3.Zero();\r\n    private _dragPlaneHitPoint: Vector3 = Vector3.Zero();\r\n    private _dragPlaneOffsetVector: Vector3 = Vector3.Zero();\r\n\r\n    private _hitPointRadius?: number; // Distance between world origin (center of globe) and the hitPoint (where initial drag started)\r\n\r\n    public override getClassName(): string {\r\n        return \"GeospatialCameraPointersInput\";\r\n    }\r\n\r\n    public override onButtonDown(evt: IPointerEvent): void {\r\n        const scene = this.camera.getScene();\r\n        let pickResult: Nullable<PickingInfo>;\r\n        switch (evt.button) {\r\n            case 0: // Left button - drag/pan globe under cursor\r\n                pickResult = scene.pick(scene.pointerX, scene.pointerY, this.camera.pickPredicate);\r\n                if (pickResult.pickedPoint && pickResult.ray) {\r\n                    // Store radius from earth center to pickedPoint, used when calculating drag plane\r\n                    this._hitPointRadius = pickResult.pickedPoint.length();\r\n\r\n                    // The dragPlaneOffsetVector will later be recalculated when drag occurs, and the delta between the offset vectors will be applied to localTranslation\r\n                    this._recalculateDragPlaneOffsetVectorToRef(this._hitPointRadius, pickResult.ray, this._dragPlaneOffsetVector);\r\n                } else {\r\n                    this._hitPointRadius = undefined; // can't drag without a hit on the globe\r\n                }\r\n                break;\r\n            case 1: // Middle button - tilt camera around cursor\r\n                pickResult = scene.pick(scene.pointerX, scene.pointerY, this.camera.pickPredicate);\r\n                pickResult.pickedPoint && (this.camera._alternateRotationPt = pickResult.pickedPoint);\r\n                break;\r\n            case 2: // Right button - tilt camera around center of screen, already the default\r\n                this.camera._alternateRotationPt = this.camera.center;\r\n                break;\r\n            default:\r\n                return;\r\n        }\r\n    }\r\n\r\n    public override onTouch(point: Nullable<PointerTouch>, offsetX: number, offsetY: number): void {\r\n        switch (point?.button) {\r\n            case 0: // Left button - drag/pan globe under cursor\r\n                this._hitPointRadius !== undefined && this._handleDrag(this._hitPointRadius);\r\n                break;\r\n            case 1: // Middle button - tilt camera around cursor\r\n            case 2: // Right button - tilt camera\r\n                this._handleTilt(offsetX, offsetY);\r\n                break;\r\n        }\r\n    }\r\n\r\n    public override onButtonUp(_evt: IPointerEvent): void {\r\n        this._hitPointRadius = undefined;\r\n        this.camera._alternateRotationPt = null;\r\n    }\r\n\r\n    /**\r\n     * The DragPlaneOffsetVector represents the vector between the dragPlane hit point and the dragPlane origin point.\r\n     * As the drag movement occurs, we will continuously recalculate this vector. The delta between the offsetVectors is the delta we will apply to the camera's localtranslation\r\n     * @param hitPointRadius The distance between the world origin (center of globe) and the initial drag hit point\r\n     * @param ray The ray from the camera to the new cursor location\r\n     * @param ref The offset vector between the drag plane's hitPoint and originPoint\r\n     */\r\n    private _recalculateDragPlaneOffsetVectorToRef(hitPointRadius: number, ray: Ray, ref: Vector3) {\r\n        // Use the camera's geocentric normal to find the dragPlaneOriginPoint which lives at hitPointRadius along the camera's geocentric normal\r\n        this.camera.position.normalizeToRef(this._dragPlaneNormal);\r\n        this._dragPlaneNormal.scaleToRef(hitPointRadius, this._dragPlaneOriginPoint);\r\n\r\n        // Now create a plane at that point, perpendicular to the camera's geocentric normal\r\n        Plane.FromPositionAndNormalToRef(this._dragPlaneOriginPoint, this._dragPlaneNormal, this._dragPlane);\r\n\r\n        // Lastly, find the _dragPlaneHitPoint where the ray intersects the _dragPlane\r\n        IntersectRayWithPlaneToRef(ray, this._dragPlane, this._dragPlaneHitPoint);\r\n\r\n        // Store the new offset between the drag plane's hitPoint and originPoint\r\n        this._dragPlaneHitPoint.subtractToRef(this._dragPlaneOriginPoint, ref);\r\n    }\r\n\r\n    private _handleDrag(hitPointRadius: number): void {\r\n        const scene = this.camera.getScene();\r\n        const pickResult = scene.pick(scene.pointerX, scene.pointerY);\r\n        if (pickResult.ray) {\r\n            const newDragPlaneOffsetVector = TmpVectors.Vector3[5];\r\n            this._recalculateDragPlaneOffsetVectorToRef(hitPointRadius, pickResult.ray, newDragPlaneOffsetVector);\r\n            const delta = TmpVectors.Vector3[6];\r\n            newDragPlaneOffsetVector.subtractToRef(this._dragPlaneOffsetVector, delta);\r\n\r\n            this._dragPlaneOffsetVector.copyFrom(newDragPlaneOffsetVector);\r\n\r\n            this.camera._perFrameGeocentricTranslation.subtractInPlace(delta); // ???\r\n        }\r\n    }\r\n\r\n    private _handleTilt(deltaX: number, deltaY: number): void {\r\n        this.camera._perFrameGeocentricRotation.y += -deltaX / this.angularSensibility; // yaw - looking side to side\r\n        this.camera._perFrameGeocentricRotation.x += -deltaY / this.angularSensibility; // pitch - look up towards sky / down towards ground\r\n    }\r\n}\r\n\r\nfunction IntersectRayWithPlaneToRef(ray: Ray, plane: Plane, ref: Vector3): boolean {\r\n    // Distance along the ray to the plane; null if no hit\r\n    const dist = ray.intersectsPlane(plane);\r\n\r\n    if (dist !== null && dist >= 0) {\r\n        ray.origin.addToRef(ray.direction.scaleToRef(dist, TmpVectors.Vector3[0]), ref);\r\n        return true;\r\n    }\r\n\r\n    return false;\r\n}\r\n"]}
+{"version":3,"file":"geospatialCameraPointersInput.js","sourceRoot":"","sources":["../../../../../dev/core/src/Cameras/Inputs/geospatialCameraPointersInput.ts"],"names":[],"mappings":"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","sourcesContent":["import type { GeospatialCamera } from \"../../Cameras/geospatialCamera\";\r\nimport type { PickingInfo } from \"../../Collisions/pickingInfo\";\r\nimport type { IPointerEvent } from \"../../Events/deviceInputEvents\";\r\nimport type { PointerTouch } from \"../../Events/pointerEvents\";\r\nimport type { Nullable } from \"../../types\";\r\nimport { OrbitCameraPointersInput } from \"./orbitCameraPointersInput\";\r\n\r\n/**\r\n * @experimental\r\n * Geospatial camera inputs can simulate dragging the globe around or tilting the camera around some point on the globe\r\n * This class will update the GeospatialCameraMovement class's movementDeltaCurrentFrame, and the camera is responsible for using these updates to calculate viewMatrix appropriately\r\n *\r\n * As of right now, the camera correction logic (to keep the camera geospatially oriented around the globe) is happening within the camera class when calculating viewmatrix\r\n * As this is experimental, it is possible we move that correction step to live within the input class (to enable non-corrected translations in the future), say if we want to allow the camera to move outside of the globe's orbit\r\n *\r\n * Left mouse button: drag globe\r\n * Middle mouse button: tilt globe around cursor location\r\n * Right mouse button: tilt globe around center of screen\r\n *\r\n */\r\nexport class GeospatialCameraPointersInput extends OrbitCameraPointersInput {\r\n    public camera: GeospatialCamera;\r\n\r\n    public override getClassName(): string {\r\n        return \"GeospatialCameraPointersInput\";\r\n    }\r\n\r\n    public override onButtonDown(evt: IPointerEvent): void {\r\n        this.camera.movement.activeInput = true;\r\n        const scene = this.camera.getScene();\r\n        let pickResult: Nullable<PickingInfo>;\r\n        switch (evt.button) {\r\n            case 0: // Left button - drag/pan globe under cursor\r\n                this.camera.movement.startDrag(scene.pointerX, scene.pointerY);\r\n                break;\r\n            case 1: // Middle button - tilt camera around cursor\r\n                pickResult = scene.pick(scene.pointerX, scene.pointerY, this.camera.pickPredicate);\r\n                pickResult.pickedPoint && (this.camera.movement.alternateRotationPt = pickResult.pickedPoint);\r\n                break;\r\n            case 2: // Right button - tilt camera around center of screen, already the default\r\n                this.camera.movement.alternateRotationPt = this.camera.center;\r\n                break;\r\n            default:\r\n                return;\r\n        }\r\n    }\r\n\r\n    public override onTouch(point: Nullable<PointerTouch>, offsetX: number, offsetY: number): void {\r\n        // Single finger touch (no button property) or left button (button 0) = drag\r\n        const button = point?.button ?? 0; // Default to button 0 (drag) if undefined\r\n        const scene = this.camera.getScene();\r\n        switch (button) {\r\n            case 0: // Left button / single touch - drag/pan globe under cursor\r\n                this.camera.movement.handleDrag(scene.pointerX, scene.pointerY);\r\n                break;\r\n            case 1: // Middle button - tilt camera\r\n            case 2: // Right button - tilt camera\r\n                this._handleTilt(offsetX, offsetY);\r\n                break;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Move camera from multitouch (pinch) zoom distances.\r\n     * @param previousPinchSquaredDistance\r\n     * @param pinchSquaredDistance\r\n     */\r\n    protected override _computePinchZoom(previousPinchSquaredDistance: number, pinchSquaredDistance: number): void {\r\n        this.camera.radius = (this.camera.radius * Math.sqrt(previousPinchSquaredDistance)) / Math.sqrt(pinchSquaredDistance);\r\n    }\r\n\r\n    /**\r\n     * Move camera from multi touch panning positions.\r\n     * In geospatialcamera, multi touch panning tilts the globe (whereas single touch will pan/drag it)\r\n     * @param previousMultiTouchPanPosition\r\n     * @param multiTouchPanPosition\r\n     */\r\n    protected override _computeMultiTouchPanning(previousMultiTouchPanPosition: Nullable<PointerTouch>, multiTouchPanPosition: Nullable<PointerTouch>): void {\r\n        if (previousMultiTouchPanPosition && multiTouchPanPosition) {\r\n            const moveDeltaX = multiTouchPanPosition.x - previousMultiTouchPanPosition.x;\r\n            const moveDeltaY = multiTouchPanPosition.y - previousMultiTouchPanPosition.y;\r\n            this._handleTilt(moveDeltaX, moveDeltaY);\r\n        }\r\n    }\r\n\r\n    public override onMultiTouch(\r\n        pointA: Nullable<PointerTouch>,\r\n        pointB: Nullable<PointerTouch>,\r\n        previousPinchSquaredDistance: number,\r\n        pinchSquaredDistance: number,\r\n        previousMultiTouchPanPosition: Nullable<PointerTouch>,\r\n        multiTouchPanPosition: Nullable<PointerTouch>\r\n    ): void {\r\n        this._shouldStartPinchZoom =\r\n            this._twoFingerActivityCount < 20 && Math.abs(Math.sqrt(pinchSquaredDistance) - Math.sqrt(previousPinchSquaredDistance)) > this.camera.limits.pinchToPanMax;\r\n        super.onMultiTouch(pointA, pointB, previousPinchSquaredDistance, pinchSquaredDistance, previousMultiTouchPanPosition, multiTouchPanPosition);\r\n    }\r\n\r\n    public override onButtonUp(_evt: IPointerEvent): void {\r\n        this.camera.movement.stopDrag();\r\n        this.camera.movement.alternateRotationPt = undefined;\r\n        this.camera.movement.activeInput = false;\r\n        super.onButtonUp(_evt);\r\n    }\r\n\r\n    private _handleTilt(deltaX: number, deltaY: number): void {\r\n        this.camera.movement.rotationAccumulatedPixels.y -= deltaX; // yaw - looking side to side\r\n        this.camera.movement.rotationAccumulatedPixels.x -= deltaY; // pitch - look up towards sky / down towards ground\r\n    }\r\n}\r\n"]}

package/Cameras/Inputs/orbitCameraPointersInput.d.ts

@@ -0,0 +1,49 @@
+import type { Nullable } from "../../types.js";
+import type { PointerTouch } from "../../Events/pointerEvents.js";
+import type { IPointerEvent } from "../../Events/deviceInputEvents.js";
+import { BaseCameraPointersInput } from "./BaseCameraPointersInput.js";
+/**
+ * Used by both arcrotatecamera and geospatialcamera, OrbitCameraPointersInputs handle pinchToZoom and multiTouchPanning
+ * as though you are orbiting around a target point
+ */
+export declare abstract class OrbitCameraPointersInput extends BaseCameraPointersInput {
+    /**
+     * Defines whether zoom (2 fingers pinch) is enabled through multitouch
+     */
+    pinchZoom: boolean;
+    /**
+     * Defines whether panning (2 fingers swipe) is enabled through multitouch.
+     */
+    multiTouchPanning: boolean;
+    /**
+     * Defines whether panning is enabled for both pan (2 fingers swipe) and
+     * zoom (pinch) through multitouch.
+     */
+    multiTouchPanAndZoom: boolean;
+    protected _isPinching: boolean;
+    protected _twoFingerActivityCount: number;
+    protected _shouldStartPinchZoom: boolean;
+    protected _computePinchZoom(_previousPinchSquaredDistance: number, _pinchSquaredDistance: number): void;
+    protected _computeMultiTouchPanning(_previousMultiTouchPanPosition: Nullable<PointerTouch>, _multiTouchPanPosition: Nullable<PointerTouch>): void;
+    /**
+     * Called on pointer POINTERMOVE event if multiple touches are active.
+     * Override this method to provide functionality.
+     * @param _pointA First point in the pair
+     * @param _pointB Second point in the pair
+     * @param previousPinchSquaredDistance Sqr Distance between the points the last time this event was fired (by this input)
+     * @param pinchSquaredDistance Sqr Distance between the points this time
+     * @param previousMultiTouchPanPosition Previous center point between the points
+     * @param multiTouchPanPosition Current center point between the points
+     */
+    onMultiTouch(_pointA: Nullable<PointerTouch>, _pointB: Nullable<PointerTouch>, previousPinchSquaredDistance: number, pinchSquaredDistance: number, previousMultiTouchPanPosition: Nullable<PointerTouch>, multiTouchPanPosition: Nullable<PointerTouch>): void;
+    /**
+     * Called each time a new POINTERUP event occurs. Ie, for each button
+     * release.
+     * @param _evt Defines the event to track
+     */
+    onButtonUp(_evt: IPointerEvent): void;
+    /**
+     * Called when window becomes inactive.
+     */
+    onLostFocus(): void;
+}

package/Cameras/Inputs/orbitCameraPointersInput.js

@@ -0,0 +1,105 @@
+import { __decorate } from "../../tslib.es6.js";
+import { serialize } from "../../Misc/decorators.js";
+import { BaseCameraPointersInput } from "./BaseCameraPointersInput.js";
+/**
+ * Used by both arcrotatecamera and geospatialcamera, OrbitCameraPointersInputs handle pinchToZoom and multiTouchPanning
+ * as though you are orbiting around a target point
+ */
+export class OrbitCameraPointersInput extends BaseCameraPointersInput {
+    constructor() {
+        super(...arguments);
+        /**
+         * Defines whether zoom (2 fingers pinch) is enabled through multitouch
+         */
+        this.pinchZoom = true;
+        /**
+         * Defines whether panning (2 fingers swipe) is enabled through multitouch.
+         */
+        this.multiTouchPanning = true;
+        /**
+         * Defines whether panning is enabled for both pan (2 fingers swipe) and
+         * zoom (pinch) through multitouch.
+         */
+        this.multiTouchPanAndZoom = true;
+        this._isPinching = false;
+        this._twoFingerActivityCount = 0;
+        this._shouldStartPinchZoom = false;
+    }
+    _computePinchZoom(_previousPinchSquaredDistance, _pinchSquaredDistance) { }
+    _computeMultiTouchPanning(_previousMultiTouchPanPosition, _multiTouchPanPosition) { }
+    /**
+     * Called on pointer POINTERMOVE event if multiple touches are active.
+     * Override this method to provide functionality.
+     * @param _pointA First point in the pair
+     * @param _pointB Second point in the pair
+     * @param previousPinchSquaredDistance Sqr Distance between the points the last time this event was fired (by this input)
+     * @param pinchSquaredDistance Sqr Distance between the points this time
+     * @param previousMultiTouchPanPosition Previous center point between the points
+     * @param multiTouchPanPosition Current center point between the points
+     */
+    onMultiTouch(_pointA, _pointB, previousPinchSquaredDistance, pinchSquaredDistance, previousMultiTouchPanPosition, multiTouchPanPosition) {
+        if (previousPinchSquaredDistance === 0 && previousMultiTouchPanPosition === null) {
+            // First time this method is called for new pinch.
+            // Next time this is called there will be a
+            // previousPinchSquaredDistance and pinchSquaredDistance to compare.
+            return;
+        }
+        if (pinchSquaredDistance === 0 && multiTouchPanPosition === null) {
+            // Last time this method is called at the end of a pinch.
+            return;
+        }
+        // Zoom and panning enabled together
+        if (this.multiTouchPanAndZoom) {
+            this._computePinchZoom(previousPinchSquaredDistance, pinchSquaredDistance);
+            this._computeMultiTouchPanning(previousMultiTouchPanPosition, multiTouchPanPosition);
+            // Zoom and panning enabled but only one at a time
+        }
+        else if (this.multiTouchPanning && this.pinchZoom) {
+            this._twoFingerActivityCount++;
+            if (this._isPinching || this._shouldStartPinchZoom) {
+                // Since pinch has not been active long, assume we intend to zoom.
+                this._computePinchZoom(previousPinchSquaredDistance, pinchSquaredDistance);
+                // Since we are pinching, remain pinching on next iteration.
+                this._isPinching = true;
+            }
+            else {
+                // Pause between pinch starting and moving implies not a zoom event. Pan instead.
+                this._computeMultiTouchPanning(previousMultiTouchPanPosition, multiTouchPanPosition);
+            }
+            // Panning enabled, zoom disabled
+        }
+        else if (this.multiTouchPanning) {
+            this._computeMultiTouchPanning(previousMultiTouchPanPosition, multiTouchPanPosition);
+            // Zoom enabled, panning disabled
+        }
+        else if (this.pinchZoom) {
+            this._computePinchZoom(previousPinchSquaredDistance, pinchSquaredDistance);
+        }
+    }
+    /**
+     * Called each time a new POINTERUP event occurs. Ie, for each button
+     * release.
+     * @param _evt Defines the event to track
+     */
+    onButtonUp(_evt) {
+        this._twoFingerActivityCount = 0;
+        this._isPinching = false;
+    }
+    /**
+     * Called when window becomes inactive.
+     */
+    onLostFocus() {
+        this._twoFingerActivityCount = 0;
+        this._isPinching = false;
+    }
+}
+__decorate([
+    serialize()
+], OrbitCameraPointersInput.prototype, "pinchZoom", void 0);
+__decorate([
+    serialize()
+], OrbitCameraPointersInput.prototype, "multiTouchPanning", void 0);
+__decorate([
+    serialize()
+], OrbitCameraPointersInput.prototype, "multiTouchPanAndZoom", void 0);
+//# sourceMappingURL=orbitCameraPointersInput.js.map

package/Cameras/Inputs/orbitCameraPointersInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orbitCameraPointersInput.js","sourceRoot":"","sources":["../../../../../dev/core/src/Cameras/Inputs/orbitCameraPointersInput.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAGlD,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAEpE;;;GAGG;AACH,MAAM,OAAgB,wBAAyB,SAAQ,uBAAuB;IAA9E;;QACI;;WAEG;QAEI,cAAS,GAAY,IAAI,CAAC;QAEjC;;WAEG;QAEI,sBAAiB,GAAY,IAAI,CAAC;QAEzC;;;WAGG;QAEI,yBAAoB,GAAY,IAAI,CAAC;QAElC,gBAAW,GAAY,KAAK,CAAC;QAC7B,4BAAuB,GAAW,CAAC,CAAC;QACpC,0BAAqB,GAAY,KAAK,CAAC;IAkFrD,CAAC;IAhFa,iBAAiB,CAAC,6BAAqC,EAAE,qBAA6B,IAAS,CAAC;IAEhG,yBAAyB,CAAC,8BAAsD,EAAE,sBAA8C,IAAS,CAAC;IAEpJ;;;;;;;;;OASG;IACa,YAAY,CACxB,OAA+B,EAC/B,OAA+B,EAC/B,4BAAoC,EACpC,oBAA4B,EAC5B,6BAAqD,EACrD,qBAA6C;QAE7C,IAAI,4BAA4B,KAAK,CAAC,IAAI,6BAA6B,KAAK,IAAI,EAAE,CAAC;YAC/E,kDAAkD;YAClD,2CAA2C;YAC3C,oEAAoE;YACpE,OAAO;QACX,CAAC;QACD,IAAI,oBAAoB,KAAK,CAAC,IAAI,qBAAqB,KAAK,IAAI,EAAE,CAAC;YAC/D,yDAAyD;YACzD,OAAO;QACX,CAAC;QAED,oCAAoC;QACpC,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,IAAI,CAAC,iBAAiB,CAAC,4BAA4B,EAAE,oBAAoB,CAAC,CAAC;YAC3E,IAAI,CAAC,yBAAyB,CAAC,6BAA6B,EAAE,qBAAqB,CAAC,CAAC;YAErF,kDAAkD;QACtD,CAAC;aAAM,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAClD,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAE/B,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;gBACjD,kEAAkE;gBAClE,IAAI,CAAC,iBAAiB,CAAC,4BAA4B,EAAE,oBAAoB,CAAC,CAAC;gBAE3E,4DAA4D;gBAC5D,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;YAC5B,CAAC;iBAAM,CAAC;gBACJ,iFAAiF;gBACjF,IAAI,CAAC,yBAAyB,CAAC,6BAA6B,EAAE,qBAAqB,CAAC,CAAC;YACzF,CAAC;YAED,iCAAiC;QACrC,CAAC;aAAM,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAChC,IAAI,CAAC,yBAAyB,CAAC,6BAA6B,EAAE,qBAAqB,CAAC,CAAC;YAErF,iCAAiC;QACrC,CAAC;aAAM,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACxB,IAAI,CAAC,iBAAiB,CAAC,4BAA4B,EAAE,oBAAoB,CAAC,CAAC;QAC/E,CAAC;IACL,CAAC;IAED;;;;OAIG;IACa,UAAU,CAAC,IAAmB;QAC1C,IAAI,CAAC,uBAAuB,GAAG,CAAC,CAAC;QACjC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC7B,CAAC;IAED;;OAEG;IACa,WAAW;QACvB,IAAI,CAAC,uBAAuB,GAAG,CAAC,CAAC;QACjC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC7B,CAAC;CACJ;AAnGU;IADN,SAAS,EAAE;2DACqB;AAM1B;IADN,SAAS,EAAE;mEAC6B;AAOlC;IADN,SAAS,EAAE;sEACgC","sourcesContent":["import type { Nullable } from \"../../types\";\r\nimport { serialize } from \"../../Misc/decorators\";\r\nimport type { PointerTouch } from \"../../Events/pointerEvents\";\r\nimport type { IPointerEvent } from \"../../Events/deviceInputEvents\";\r\nimport { BaseCameraPointersInput } from \"./BaseCameraPointersInput\";\r\n\r\n/**\r\n * Used by both arcrotatecamera and geospatialcamera, OrbitCameraPointersInputs handle pinchToZoom and multiTouchPanning\r\n * as though you are orbiting around a target point\r\n */\r\nexport abstract class OrbitCameraPointersInput extends BaseCameraPointersInput {\r\n    /**\r\n     * Defines whether zoom (2 fingers pinch) is enabled through multitouch\r\n     */\r\n    @serialize()\r\n    public pinchZoom: boolean = true;\r\n\r\n    /**\r\n     * Defines whether panning (2 fingers swipe) is enabled through multitouch.\r\n     */\r\n    @serialize()\r\n    public multiTouchPanning: boolean = true;\r\n\r\n    /**\r\n     * Defines whether panning is enabled for both pan (2 fingers swipe) and\r\n     * zoom (pinch) through multitouch.\r\n     */\r\n    @serialize()\r\n    public multiTouchPanAndZoom: boolean = true;\r\n\r\n    protected _isPinching: boolean = false;\r\n    protected _twoFingerActivityCount: number = 0;\r\n    protected _shouldStartPinchZoom: boolean = false;\r\n\r\n    protected _computePinchZoom(_previousPinchSquaredDistance: number, _pinchSquaredDistance: number): void {}\r\n\r\n    protected _computeMultiTouchPanning(_previousMultiTouchPanPosition: Nullable<PointerTouch>, _multiTouchPanPosition: Nullable<PointerTouch>): void {}\r\n\r\n    /**\r\n     * Called on pointer POINTERMOVE event if multiple touches are active.\r\n     * Override this method to provide functionality.\r\n     * @param _pointA First point in the pair\r\n     * @param _pointB Second point in the pair\r\n     * @param previousPinchSquaredDistance Sqr Distance between the points the last time this event was fired (by this input)\r\n     * @param pinchSquaredDistance Sqr Distance between the points this time\r\n     * @param previousMultiTouchPanPosition Previous center point between the points\r\n     * @param multiTouchPanPosition Current center point between the points\r\n     */\r\n    public override onMultiTouch(\r\n        _pointA: Nullable<PointerTouch>,\r\n        _pointB: Nullable<PointerTouch>,\r\n        previousPinchSquaredDistance: number,\r\n        pinchSquaredDistance: number,\r\n        previousMultiTouchPanPosition: Nullable<PointerTouch>,\r\n        multiTouchPanPosition: Nullable<PointerTouch>\r\n    ): void {\r\n        if (previousPinchSquaredDistance === 0 && previousMultiTouchPanPosition === null) {\r\n            // First time this method is called for new pinch.\r\n            // Next time this is called there will be a\r\n            // previousPinchSquaredDistance and pinchSquaredDistance to compare.\r\n            return;\r\n        }\r\n        if (pinchSquaredDistance === 0 && multiTouchPanPosition === null) {\r\n            // Last time this method is called at the end of a pinch.\r\n            return;\r\n        }\r\n\r\n        // Zoom and panning enabled together\r\n        if (this.multiTouchPanAndZoom) {\r\n            this._computePinchZoom(previousPinchSquaredDistance, pinchSquaredDistance);\r\n            this._computeMultiTouchPanning(previousMultiTouchPanPosition, multiTouchPanPosition);\r\n\r\n            // Zoom and panning enabled but only one at a time\r\n        } else if (this.multiTouchPanning && this.pinchZoom) {\r\n            this._twoFingerActivityCount++;\r\n\r\n            if (this._isPinching || this._shouldStartPinchZoom) {\r\n                // Since pinch has not been active long, assume we intend to zoom.\r\n                this._computePinchZoom(previousPinchSquaredDistance, pinchSquaredDistance);\r\n\r\n                // Since we are pinching, remain pinching on next iteration.\r\n                this._isPinching = true;\r\n            } else {\r\n                // Pause between pinch starting and moving implies not a zoom event. Pan instead.\r\n                this._computeMultiTouchPanning(previousMultiTouchPanPosition, multiTouchPanPosition);\r\n            }\r\n\r\n            // Panning enabled, zoom disabled\r\n        } else if (this.multiTouchPanning) {\r\n            this._computeMultiTouchPanning(previousMultiTouchPanPosition, multiTouchPanPosition);\r\n\r\n            // Zoom enabled, panning disabled\r\n        } else if (this.pinchZoom) {\r\n            this._computePinchZoom(previousPinchSquaredDistance, pinchSquaredDistance);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Called each time a new POINTERUP event occurs. Ie, for each button\r\n     * release.\r\n     * @param _evt Defines the event to track\r\n     */\r\n    public override onButtonUp(_evt: IPointerEvent): void {\r\n        this._twoFingerActivityCount = 0;\r\n        this._isPinching = false;\r\n    }\r\n\r\n    /**\r\n     * Called when window becomes inactive.\r\n     */\r\n    public override onLostFocus(): void {\r\n        this._twoFingerActivityCount = 0;\r\n        this._isPinching = false;\r\n    }\r\n}\r\n"]}

package/Cameras/Limits/geospatialLimits.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Limits for geospatial cameras with altitude/radius synchronization
+ */
+export declare class GeospatialLimits {
+    private _altitudeMin;
+    private _altitudeMax;
+    private _planetRadius;
+    private _radiusMin;
+    private _radiusMax;
+    /** Gets the minimum pitch angle (angle from horizon) -- 0 means looking straight down at planet */
+    pitchMin: number;
+    /**  Gets the maximum pitch angle (angle from horizon) -- Pi/1 means looking at horizon */
+    pitchMax: number;
+    /** Gets the minimum yaw angle (rotation around up axis) */
+    yawMin: number;
+    /** Gets the maximum yaw angle (rotation around up axis) */
+    yawMax: number;
+    /**
+     * Defines the distance used to consider the camera in pan mode vs pinch/zoom.
+     * Basically if your fingers moves away from more than this distance you will be considered
+     * in pinch mode.
+     */
+    pinchToPanMax: number;
+    /**
+     * @param planetRadius The radius of the planet (used for altitude/radius conversions)
+     */
+    constructor(planetRadius: number);
+    /**
+     * Gets the minimum altitude (height above planet surface)
+     */
+    get altitudeMin(): number;
+    /**
+     * Sets the minimum altitude and syncs it with radius
+     */
+    set altitudeMin(value: number);
+    /**
+     * Gets the maximum altitude (height above planet surface)
+     */
+    get altitudeMax(): number;
+    /**
+     * Sets the maximum altitude and syncs it with radius
+     */
+    set altitudeMax(value: number);
+    get radiusMin(): number;
+    /**
+     * Sets the minimum radius and syncs it with altitude
+     */
+    set radiusMin(value: number);
+    get radiusMax(): number;
+    /**
+     * Sets the maximum radius and syncs it with altitude
+     */
+    set radiusMax(value: number);
+    /**
+     * Gets the planet radius used for altitude/radius conversions
+     */
+    get planetRadius(): number;
+    /** Sets the planet radius and updates the radius limits to maintain current altitude */
+    set planetRadius(value: number);
+}

package/Cameras/Limits/geospatialLimits.js

@@ -0,0 +1,89 @@
+import { Epsilon } from "../../Maths/math.constants.js";
+/**
+ * Limits for geospatial cameras with altitude/radius synchronization
+ */
+export class GeospatialLimits {
+    /**
+     * @param planetRadius The radius of the planet (used for altitude/radius conversions)
+     */
+    constructor(planetRadius) {
+        this._altitudeMin = Epsilon;
+        this._radiusMin = Epsilon;
+        this._radiusMax = Infinity;
+        /** Gets the minimum pitch angle (angle from horizon) -- 0 means looking straight down at planet */
+        this.pitchMin = Epsilon;
+        /**  Gets the maximum pitch angle (angle from horizon) -- Pi/1 means looking at horizon */
+        this.pitchMax = Math.PI / 2;
+        /** Gets the minimum yaw angle (rotation around up axis) */
+        this.yawMin = -Infinity;
+        /** Gets the maximum yaw angle (rotation around up axis) */
+        this.yawMax = Infinity;
+        /**
+         * Defines the distance used to consider the camera in pan mode vs pinch/zoom.
+         * Basically if your fingers moves away from more than this distance you will be considered
+         * in pinch mode.
+         */
+        this.pinchToPanMax = 20;
+        this._planetRadius = planetRadius;
+    }
+    /**
+     * Gets the minimum altitude (height above planet surface)
+     */
+    get altitudeMin() {
+        return this._altitudeMin;
+    }
+    /**
+     * Sets the minimum altitude and syncs it with radius
+     */
+    set altitudeMin(value) {
+        this._altitudeMin = value;
+        this._radiusMin = this._planetRadius + value;
+    }
+    /**
+     * Gets the maximum altitude (height above planet surface)
+     */
+    get altitudeMax() {
+        return this._altitudeMax;
+    }
+    /**
+     * Sets the maximum altitude and syncs it with radius
+     */
+    set altitudeMax(value) {
+        this._altitudeMax = value;
+        this._radiusMax = this._planetRadius + value;
+    }
+    get radiusMin() {
+        return this._radiusMin;
+    }
+    /**
+     * Sets the minimum radius and syncs it with altitude
+     */
+    set radiusMin(value) {
+        this._radiusMin = value;
+        this._altitudeMin = value - this._planetRadius;
+    }
+    get radiusMax() {
+        return this._radiusMax;
+    }
+    /**
+     * Sets the maximum radius and syncs it with altitude
+     */
+    set radiusMax(value) {
+        this._radiusMax = value;
+        this._altitudeMax = value - this._planetRadius;
+    }
+    /**
+     * Gets the planet radius used for altitude/radius conversions
+     */
+    get planetRadius() {
+        return this._planetRadius;
+    }
+    /** Sets the planet radius and updates the radius limits to maintain current altitude */
+    set planetRadius(value) {
+        this._planetRadius = value;
+        // Update radius limits to maintain current altitude
+        this._radiusMin = value + this._altitudeMin;
+        this._radiusMax = value + this._altitudeMax;
+    }
+}
+//# sourceMappingURL=geospatialLimits.js.map

package/Cameras/Limits/geospatialLimits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geospatialLimits.js","sourceRoot":"","sources":["../../../../../dev/core/src/Cameras/Limits/geospatialLimits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AACrD;;GAEG;AACH,MAAM,OAAO,gBAAgB;IAyBzB;;OAEG;IACH,YAAY,YAAoB;QA3BxB,iBAAY,GAAW,OAAO,CAAC;QAG/B,eAAU,GAAW,OAAO,CAAC;QAC7B,eAAU,GAAW,QAAQ,CAAC;QAEtC,mGAAmG;QAC5F,aAAQ,GAAW,OAAO,CAAC;QAElC,0FAA0F;QACnF,aAAQ,GAAW,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;QAEtC,2DAA2D;QACpD,WAAM,GAAW,CAAC,QAAQ,CAAC;QAElC,2DAA2D;QACpD,WAAM,GAAW,QAAQ,CAAC;QACjC;;;;WAIG;QACI,kBAAa,GAAW,EAAE,CAAC;QAM9B,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,IAAW,WAAW;QAClB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,IAAW,WAAW,CAAC,KAAa;QAChC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IACjD,CAAC;IAED;;OAEG;IACH,IAAW,WAAW;QAClB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,IAAW,WAAW,CAAC,KAAa;QAChC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IACjD,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,IAAW,SAAS,CAAC,KAAa;QAC9B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC;IACnD,CAAC;IAED,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,IAAW,SAAS,CAAC,KAAa;QAC9B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,YAAY,GAAG,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC;IACnD,CAAC;IAED;;OAEG;IACH,IAAW,YAAY;QACnB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAED,wFAAwF;IACxF,IAAW,YAAY,CAAC,KAAa;QACjC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAC3B,oDAAoD;QACpD,IAAI,CAAC,UAAU,GAAG,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC;QAC5C,IAAI,CAAC,UAAU,GAAG,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC;IAChD,CAAC;CACJ","sourcesContent":["import { Epsilon } from \"../../Maths/math.constants\";\r\n/**\r\n * Limits for geospatial cameras with altitude/radius synchronization\r\n */\r\nexport class GeospatialLimits {\r\n    private _altitudeMin: number = Epsilon;\r\n    private _altitudeMax: number;\r\n    private _planetRadius: number;\r\n    private _radiusMin: number = Epsilon;\r\n    private _radiusMax: number = Infinity;\r\n\r\n    /** Gets the minimum pitch angle (angle from horizon) -- 0 means looking straight down at planet */\r\n    public pitchMin: number = Epsilon;\r\n\r\n    /**  Gets the maximum pitch angle (angle from horizon) -- Pi/1 means looking at horizon */\r\n    public pitchMax: number = Math.PI / 2;\r\n\r\n    /** Gets the minimum yaw angle (rotation around up axis) */\r\n    public yawMin: number = -Infinity;\r\n\r\n    /** Gets the maximum yaw angle (rotation around up axis) */\r\n    public yawMax: number = Infinity;\r\n    /**\r\n     * Defines the distance used to consider the camera in pan mode vs pinch/zoom.\r\n     * Basically if your fingers moves away from more than this distance you will be considered\r\n     * in pinch mode.\r\n     */\r\n    public pinchToPanMax: number = 20;\r\n\r\n    /**\r\n     * @param planetRadius The radius of the planet (used for altitude/radius conversions)\r\n     */\r\n    constructor(planetRadius: number) {\r\n        this._planetRadius = planetRadius;\r\n    }\r\n\r\n    /**\r\n     * Gets the minimum altitude (height above planet surface)\r\n     */\r\n    public get altitudeMin(): number {\r\n        return this._altitudeMin;\r\n    }\r\n\r\n    /**\r\n     * Sets the minimum altitude and syncs it with radius\r\n     */\r\n    public set altitudeMin(value: number) {\r\n        this._altitudeMin = value;\r\n        this._radiusMin = this._planetRadius + value;\r\n    }\r\n\r\n    /**\r\n     * Gets the maximum altitude (height above planet surface)\r\n     */\r\n    public get altitudeMax(): number {\r\n        return this._altitudeMax;\r\n    }\r\n\r\n    /**\r\n     * Sets the maximum altitude and syncs it with radius\r\n     */\r\n    public set altitudeMax(value: number) {\r\n        this._altitudeMax = value;\r\n        this._radiusMax = this._planetRadius + value;\r\n    }\r\n\r\n    public get radiusMin(): number {\r\n        return this._radiusMin;\r\n    }\r\n\r\n    /**\r\n     * Sets the minimum radius and syncs it with altitude\r\n     */\r\n    public set radiusMin(value: number) {\r\n        this._radiusMin = value;\r\n        this._altitudeMin = value - this._planetRadius;\r\n    }\r\n\r\n    public get radiusMax(): number {\r\n        return this._radiusMax;\r\n    }\r\n\r\n    /**\r\n     * Sets the maximum radius and syncs it with altitude\r\n     */\r\n    public set radiusMax(value: number) {\r\n        this._radiusMax = value;\r\n        this._altitudeMax = value - this._planetRadius;\r\n    }\r\n\r\n    /**\r\n     * Gets the planet radius used for altitude/radius conversions\r\n     */\r\n    public get planetRadius(): number {\r\n        return this._planetRadius;\r\n    }\r\n\r\n    /** Sets the planet radius and updates the radius limits to maintain current altitude */\r\n    public set planetRadius(value: number) {\r\n        this._planetRadius = value;\r\n        // Update radius limits to maintain current altitude\r\n        this._radiusMin = value + this._altitudeMin;\r\n        this._radiusMax = value + this._altitudeMax;\r\n    }\r\n}\r\n"]}