@onerjs/core 8.36.2 → 8.36.4

package/Behaviors/Cameras/geospatialClippingBehavior.d.ts

@@ -0,0 +1,40 @@
+import type { Behavior } from "../../Behaviors/behavior.js";
+import type { GeospatialCamera } from "../../Cameras/geospatialCamera.js";
+import type { Nullable } from "../../types.js";
+/**
+ * The GeospatialClippingBehavior automatically adjusts the near and far clip planes of a GeospatialCamera
+ * based on altitude and viewing angle to optimize depth buffer precision for geospatial applications.
+ *
+ * When viewing from high altitudes looking down, a larger near plane can be used.
+ * When viewing horizontally at ground level, a smaller near plane is needed to avoid clipping nearby terrain.
+ * The far plane is calculated based on the visible horizon distance.
+ */
+export declare class GeospatialClippingBehavior implements Behavior<GeospatialCamera> {
+    /**
+     * Gets the name of the behavior.
+     */
+    get name(): string;
+    private _attachedCamera;
+    private _onBeforeRenderObserver;
+    /**
+     * Gets the attached camera.
+     */
+    get attachedNode(): Nullable<GeospatialCamera>;
+    /**
+     * Initializes the behavior.
+     */
+    init(): void;
+    /**
+     * Attaches the behavior to its geospatial camera.
+     * @param camera Defines the camera to attach the behavior to
+     */
+    attach(camera: GeospatialCamera): void;
+    /**
+     * Detaches the behavior from its current geospatial camera.
+     */
+    detach(): void;
+    /**
+     * Updates the camera's near and far clip planes based on altitude and viewing angle.
+     */
+    private _updateCameraClipPlanes;
+}

package/Behaviors/Cameras/geospatialClippingBehavior.js

@@ -0,0 +1,80 @@
+/**
+ * The GeospatialClippingBehavior automatically adjusts the near and far clip planes of a GeospatialCamera
+ * based on altitude and viewing angle to optimize depth buffer precision for geospatial applications.
+ *
+ * When viewing from high altitudes looking down, a larger near plane can be used.
+ * When viewing horizontally at ground level, a smaller near plane is needed to avoid clipping nearby terrain.
+ * The far plane is calculated based on the visible horizon distance.
+ */
+export class GeospatialClippingBehavior {
+    constructor() {
+        this._attachedCamera = null;
+        this._onBeforeRenderObserver = null;
+    }
+    /**
+     * Gets the name of the behavior.
+     */
+    get name() {
+        return "GeospatialClipping";
+    }
+    /**
+     * Gets the attached camera.
+     */
+    get attachedNode() {
+        return this._attachedCamera;
+    }
+    /**
+     * Initializes the behavior.
+     */
+    init() {
+        // Do nothing
+    }
+    /**
+     * Attaches the behavior to its geospatial camera.
+     * @param camera Defines the camera to attach the behavior to
+     */
+    attach(camera) {
+        this._attachedCamera = camera;
+        const scene = camera.getScene();
+        this._onBeforeRenderObserver = scene.onBeforeRenderObservable.add(() => {
+            this._updateCameraClipPlanes();
+        });
+    }
+    /**
+     * Detaches the behavior from its current geospatial camera.
+     */
+    detach() {
+        if (this._attachedCamera) {
+            const scene = this._attachedCamera.getScene();
+            if (this._onBeforeRenderObserver) {
+                scene.onBeforeRenderObservable.remove(this._onBeforeRenderObserver);
+                this._onBeforeRenderObserver = null;
+            }
+        }
+        this._attachedCamera = null;
+    }
+    /**
+     * Updates the camera's near and far clip planes based on altitude and viewing angle.
+     */
+    _updateCameraClipPlanes() {
+        const camera = this._attachedCamera;
+        if (!camera) {
+            return;
+        }
+        const planetRadius = camera.limits.planetRadius;
+        const altitude = Math.max(1, camera.radius);
+        const pitch = camera.pitch; // 0 = looking down, π/2 = looking at horizon
+        // Near plane calculation:
+        // - When looking down (pitch ≈ 0): nearest visible point is roughly at altitude distance
+        // - When looking at horizon (pitch ≈ π/2): nearby terrain can be much closer
+        // Use pitch to blend between a small near (for horizontal view) and altitude-based near (for top-down)
+        const pitchFactor = Math.sin(pitch); // 0 when looking down, 1 at horizon
+        const minNearHorizontal = 1; // When looking horizontally, need small near plane
+        const minNearVertical = Math.max(1, altitude * 0.01); // When looking down, can use larger near
+        camera.minZ = minNearHorizontal + (minNearVertical - minNearHorizontal) * (1 - pitchFactor);
+        // Far plane: see to the horizon and beyond
+        const horizonDist = Math.sqrt(2 * planetRadius * altitude + altitude * altitude);
+        camera.maxZ = horizonDist + planetRadius * 0.1;
+    }
+}
+//# sourceMappingURL=geospatialClippingBehavior.js.map

package/Behaviors/Cameras/geospatialClippingBehavior.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geospatialClippingBehavior.js","sourceRoot":"","sources":["../../../../../dev/core/src/Behaviors/Cameras/geospatialClippingBehavior.ts"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,MAAM,OAAO,0BAA0B;IAAvC;QAQY,oBAAe,GAA+B,IAAI,CAAC;QACnD,4BAAuB,GAA8B,IAAI,CAAC;IAsEtE,CAAC;IA9EG;;OAEG;IACH,IAAW,IAAI;QACX,OAAO,oBAAoB,CAAC;IAChC,CAAC;IAKD;;OAEG;IACH,IAAW,YAAY;QACnB,OAAO,IAAI,CAAC,eAAe,CAAC;IAChC,CAAC;IAED;;OAEG;IACI,IAAI;QACP,aAAa;IACjB,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,MAAwB;QAClC,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC;QAC9B,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;QAEhC,IAAI,CAAC,uBAAuB,GAAG,KAAK,CAAC,wBAAwB,CAAC,GAAG,CAAC,GAAG,EAAE;YACnE,IAAI,CAAC,uBAAuB,EAAE,CAAC;QACnC,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACI,MAAM;QACT,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC;YAC9C,IAAI,IAAI,CAAC,uBAAuB,EAAE,CAAC;gBAC/B,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;gBACpE,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC;YACxC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;IAChC,CAAC;IAED;;OAEG;IACK,uBAAuB;QAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;QACpC,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,OAAO;QACX,CAAC;QAED,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC;QAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5C,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,6CAA6C;QAEzE,0BAA0B;QAC1B,yFAAyF;QACzF,6EAA6E;QAE7E,uGAAuG;QACvG,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,oCAAoC;QACzE,MAAM,iBAAiB,GAAG,CAAC,CAAC,CAAC,mDAAmD;QAChF,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,yCAAyC;QAC/F,MAAM,CAAC,IAAI,GAAG,iBAAiB,GAAG,CAAC,eAAe,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC;QAE5F,2CAA2C;QAC3C,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,YAAY,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC,CAAC;QACjF,MAAM,CAAC,IAAI,GAAG,WAAW,GAAG,YAAY,GAAG,GAAG,CAAC;IACnD,CAAC;CACJ","sourcesContent":["import type { Behavior } from \"../../Behaviors/behavior\";\r\nimport type { GeospatialCamera } from \"../../Cameras/geospatialCamera\";\r\nimport type { Nullable } from \"../../types\";\r\nimport type { Observer } from \"../../Misc/observable\";\r\nimport type { Scene } from \"../../scene\";\r\n\r\n/**\r\n * The GeospatialClippingBehavior automatically adjusts the near and far clip planes of a GeospatialCamera\r\n * based on altitude and viewing angle to optimize depth buffer precision for geospatial applications.\r\n *\r\n * When viewing from high altitudes looking down, a larger near plane can be used.\r\n * When viewing horizontally at ground level, a smaller near plane is needed to avoid clipping nearby terrain.\r\n * The far plane is calculated based on the visible horizon distance.\r\n */\r\nexport class GeospatialClippingBehavior implements Behavior<GeospatialCamera> {\r\n    /**\r\n     * Gets the name of the behavior.\r\n     */\r\n    public get name(): string {\r\n        return \"GeospatialClipping\";\r\n    }\r\n\r\n    private _attachedCamera: Nullable<GeospatialCamera> = null;\r\n    private _onBeforeRenderObserver: Nullable<Observer<Scene>> = null;\r\n\r\n    /**\r\n     * Gets the attached camera.\r\n     */\r\n    public get attachedNode(): Nullable<GeospatialCamera> {\r\n        return this._attachedCamera;\r\n    }\r\n\r\n    /**\r\n     * Initializes the behavior.\r\n     */\r\n    public init(): void {\r\n        // Do nothing\r\n    }\r\n\r\n    /**\r\n     * Attaches the behavior to its geospatial camera.\r\n     * @param camera Defines the camera to attach the behavior to\r\n     */\r\n    public attach(camera: GeospatialCamera): void {\r\n        this._attachedCamera = camera;\r\n        const scene = camera.getScene();\r\n\r\n        this._onBeforeRenderObserver = scene.onBeforeRenderObservable.add(() => {\r\n            this._updateCameraClipPlanes();\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Detaches the behavior from its current geospatial camera.\r\n     */\r\n    public detach(): void {\r\n        if (this._attachedCamera) {\r\n            const scene = this._attachedCamera.getScene();\r\n            if (this._onBeforeRenderObserver) {\r\n                scene.onBeforeRenderObservable.remove(this._onBeforeRenderObserver);\r\n                this._onBeforeRenderObserver = null;\r\n            }\r\n        }\r\n        this._attachedCamera = null;\r\n    }\r\n\r\n    /**\r\n     * Updates the camera's near and far clip planes based on altitude and viewing angle.\r\n     */\r\n    private _updateCameraClipPlanes(): void {\r\n        const camera = this._attachedCamera;\r\n        if (!camera) {\r\n            return;\r\n        }\r\n\r\n        const planetRadius = camera.limits.planetRadius;\r\n        const altitude = Math.max(1, camera.radius);\r\n        const pitch = camera.pitch; // 0 = looking down, π/2 = looking at horizon\r\n\r\n        // Near plane calculation:\r\n        // - When looking down (pitch ≈ 0): nearest visible point is roughly at altitude distance\r\n        // - When looking at horizon (pitch ≈ π/2): nearby terrain can be much closer\r\n\r\n        // Use pitch to blend between a small near (for horizontal view) and altitude-based near (for top-down)\r\n        const pitchFactor = Math.sin(pitch); // 0 when looking down, 1 at horizon\r\n        const minNearHorizontal = 1; // When looking horizontally, need small near plane\r\n        const minNearVertical = Math.max(1, altitude * 0.01); // When looking down, can use larger near\r\n        camera.minZ = minNearHorizontal + (minNearVertical - minNearHorizontal) * (1 - pitchFactor);\r\n\r\n        // Far plane: see to the horizon and beyond\r\n        const horizonDist = Math.sqrt(2 * planetRadius * altitude + altitude * altitude);\r\n        camera.maxZ = horizonDist + planetRadius * 0.1;\r\n    }\r\n}\r\n"]}

package/Behaviors/Cameras/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./autoRotationBehavior.js";
 export * from "./bouncingBehavior.js";
 export * from "./framingBehavior.js";
+export * from "./interpolatingBehavior.js";
+export * from "./geospatialClippingBehavior.js";

package/Behaviors/Cameras/index.js

@@ -1,4 +1,6 @@
 export * from "./autoRotationBehavior.js";
 export * from "./bouncingBehavior.js";
 export * from "./framingBehavior.js";
+export * from "./interpolatingBehavior.js";
+export * from "./geospatialClippingBehavior.js";
 //# sourceMappingURL=index.js.map

package/Behaviors/Cameras/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../dev/core/src/Behaviors/Cameras/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC","sourcesContent":["export * from \"./autoRotationBehavior\";\r\nexport * from \"./bouncingBehavior\";\r\nexport * from \"./framingBehavior\";\r\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../dev/core/src/Behaviors/Cameras/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC","sourcesContent":["export * from \"./autoRotationBehavior\";\r\nexport * from \"./bouncingBehavior\";\r\nexport * from \"./framingBehavior\";\r\nexport * from \"./interpolatingBehavior\";\r\nexport * from \"./geospatialClippingBehavior\";\r\n"]}

package/Cameras/Inputs/geospatialCameraPointersInput.js

@@ -72,14 +72,16 @@ export class GeospatialCameraPointersInput extends OrbitCameraPointersInput {
                     // Scale zoom by distance to picked point
                     const distanceToPoint = this.camera.position.subtract(pickResult.pickedPoint).length();
                     const zoomDistance = pinchDelta * distanceToPoint * 0.005;
-                    this.camera.zoomToPoint(pickResult.pickedPoint, zoomDistance);
+                    const clampedZoom = this.camera.limits.clampZoomDistance(zoomDistance, this.camera.radius, distanceToPoint);
+                    this.camera.zoomToPoint(pickResult.pickedPoint, clampedZoom);
                     return;
                 }
             }
         }
         // Fallback: scale zoom by camera radius along lookat vector
         const zoomDistance = pinchDelta * this.camera.radius * 0.005;
-        this.camera.zoomAlongLookAt(zoomDistance);
+        const clampedZoom = this.camera.limits.clampZoomDistance(zoomDistance, this.camera.radius);
+        this.camera.zoomAlongLookAt(clampedZoom);
     }
     /**
      * Move camera from multi touch panning positions.

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 { 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\r\n * Right mouse button: tilt globe\r\n *\r\n */\r\nexport class GeospatialCameraPointersInput extends OrbitCameraPointersInput {\r\n    public camera: GeospatialCamera;\r\n\r\n    private _initialPinchSquaredDistance: number = 0;\r\n    private _pinchCentroid: Nullable<PointerTouch> = null;\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        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            default:\r\n                break;\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     * Zooms towards the centroid (midpoint between the two fingers).\r\n     * @param previousPinchSquaredDistance\r\n     * @param pinchSquaredDistance\r\n     */\r\n    protected override _computePinchZoom(previousPinchSquaredDistance: number, pinchSquaredDistance: number): void {\r\n        // Calculate zoom distance based on pinch delta\r\n        const previousDistance = Math.sqrt(previousPinchSquaredDistance);\r\n        const currentDistance = Math.sqrt(pinchSquaredDistance);\r\n        const pinchDelta = currentDistance - previousDistance;\r\n\r\n        // Try to zoom towards centroid if we have it\r\n        if (this._pinchCentroid) {\r\n            const scene = this.camera.getScene();\r\n            const engine = scene.getEngine();\r\n            const canvasRect = engine.getInputElementClientRect();\r\n\r\n            if (canvasRect) {\r\n                // Convert centroid from clientX/Y to canvas-relative coordinates (same as scene.pointerX/Y)\r\n                const canvasX = this._pinchCentroid.x - canvasRect.left;\r\n                const canvasY = this._pinchCentroid.y - canvasRect.top;\r\n\r\n                // Pick at centroid\r\n                const pickResult = scene.pick(canvasX, canvasY, this.camera.pickPredicate);\r\n                if (pickResult?.pickedPoint) {\r\n                    // Scale zoom by distance to picked point\r\n                    const distanceToPoint = this.camera.position.subtract(pickResult.pickedPoint).length();\r\n                    const zoomDistance = pinchDelta * distanceToPoint * 0.005;\r\n                    this.camera.zoomToPoint(pickResult.pickedPoint, zoomDistance);\r\n                    return;\r\n                }\r\n            }\r\n        }\r\n\r\n        // Fallback: scale zoom by camera radius along lookat vector\r\n        const zoomDistance = pinchDelta * this.camera.radius * 0.005;\r\n        this.camera.zoomAlongLookAt(zoomDistance);\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 onDoubleTap(type: string): void {\r\n        const pickResult = this.camera._scene.pick(this.camera._scene.pointerX, this.camera._scene.pointerY, this.camera.pickPredicate);\r\n        if (pickResult.pickedPoint) {\r\n            void this.camera.flyToPointAsync(pickResult.pickedPoint);\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        // Store centroid for use in _computePinchZoom (it's already calculated by parent)\r\n        this._pinchCentroid = multiTouchPanPosition;\r\n\r\n        // Reset on gesture end\r\n        if (pinchSquaredDistance === 0 && multiTouchPanPosition === null) {\r\n            this._initialPinchSquaredDistance = 0;\r\n            this._pinchCentroid = null;\r\n            super.onMultiTouch(pointA, pointB, previousPinchSquaredDistance, pinchSquaredDistance, previousMultiTouchPanPosition, multiTouchPanPosition);\r\n            return;\r\n        }\r\n\r\n        // Track initial distance at gesture start for cumulative threshold detection\r\n        if (this._initialPinchSquaredDistance === 0 && pinchSquaredDistance !== 0) {\r\n            this._initialPinchSquaredDistance = pinchSquaredDistance;\r\n        }\r\n\r\n        // Use cumulative delta from gesture start for threshold detection (more forgiving than frame-to-frame)\r\n        const cumulativeDelta = Math.abs(Math.sqrt(pinchSquaredDistance) - Math.sqrt(this._initialPinchSquaredDistance));\r\n        this._shouldStartPinchZoom = this._twoFingerActivityCount < 20 && cumulativeDelta > this.camera.limits.pinchToPanMax;\r\n\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.activeInput = false;\r\n        this._initialPinchSquaredDistance = 0;\r\n        this._pinchCentroid = null;\r\n        super.onButtonUp(_evt);\r\n    }\r\n\r\n    public override onLostFocus(): void {\r\n        this._initialPinchSquaredDistance = 0;\r\n        this._pinchCentroid = null;\r\n        super.onLostFocus();\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"]}
+{"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 { 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\r\n * Right mouse button: tilt globe\r\n *\r\n */\r\nexport class GeospatialCameraPointersInput extends OrbitCameraPointersInput {\r\n    public camera: GeospatialCamera;\r\n\r\n    private _initialPinchSquaredDistance: number = 0;\r\n    private _pinchCentroid: Nullable<PointerTouch> = null;\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        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            default:\r\n                break;\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     * Zooms towards the centroid (midpoint between the two fingers).\r\n     * @param previousPinchSquaredDistance\r\n     * @param pinchSquaredDistance\r\n     */\r\n    protected override _computePinchZoom(previousPinchSquaredDistance: number, pinchSquaredDistance: number): void {\r\n        // Calculate zoom distance based on pinch delta\r\n        const previousDistance = Math.sqrt(previousPinchSquaredDistance);\r\n        const currentDistance = Math.sqrt(pinchSquaredDistance);\r\n        const pinchDelta = currentDistance - previousDistance;\r\n\r\n        // Try to zoom towards centroid if we have it\r\n        if (this._pinchCentroid) {\r\n            const scene = this.camera.getScene();\r\n            const engine = scene.getEngine();\r\n            const canvasRect = engine.getInputElementClientRect();\r\n\r\n            if (canvasRect) {\r\n                // Convert centroid from clientX/Y to canvas-relative coordinates (same as scene.pointerX/Y)\r\n                const canvasX = this._pinchCentroid.x - canvasRect.left;\r\n                const canvasY = this._pinchCentroid.y - canvasRect.top;\r\n\r\n                // Pick at centroid\r\n                const pickResult = scene.pick(canvasX, canvasY, this.camera.pickPredicate);\r\n                if (pickResult?.pickedPoint) {\r\n                    // Scale zoom by distance to picked point\r\n                    const distanceToPoint = this.camera.position.subtract(pickResult.pickedPoint).length();\r\n                    const zoomDistance = pinchDelta * distanceToPoint * 0.005;\r\n                    const clampedZoom = this.camera.limits.clampZoomDistance(zoomDistance, this.camera.radius, distanceToPoint);\r\n                    this.camera.zoomToPoint(pickResult.pickedPoint, clampedZoom);\r\n                    return;\r\n                }\r\n            }\r\n        }\r\n\r\n        // Fallback: scale zoom by camera radius along lookat vector\r\n        const zoomDistance = pinchDelta * this.camera.radius * 0.005;\r\n        const clampedZoom = this.camera.limits.clampZoomDistance(zoomDistance, this.camera.radius);\r\n        this.camera.zoomAlongLookAt(clampedZoom);\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 onDoubleTap(type: string): void {\r\n        const pickResult = this.camera._scene.pick(this.camera._scene.pointerX, this.camera._scene.pointerY, this.camera.pickPredicate);\r\n        if (pickResult.pickedPoint) {\r\n            void this.camera.flyToPointAsync(pickResult.pickedPoint);\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        // Store centroid for use in _computePinchZoom (it's already calculated by parent)\r\n        this._pinchCentroid = multiTouchPanPosition;\r\n\r\n        // Reset on gesture end\r\n        if (pinchSquaredDistance === 0 && multiTouchPanPosition === null) {\r\n            this._initialPinchSquaredDistance = 0;\r\n            this._pinchCentroid = null;\r\n            super.onMultiTouch(pointA, pointB, previousPinchSquaredDistance, pinchSquaredDistance, previousMultiTouchPanPosition, multiTouchPanPosition);\r\n            return;\r\n        }\r\n\r\n        // Track initial distance at gesture start for cumulative threshold detection\r\n        if (this._initialPinchSquaredDistance === 0 && pinchSquaredDistance !== 0) {\r\n            this._initialPinchSquaredDistance = pinchSquaredDistance;\r\n        }\r\n\r\n        // Use cumulative delta from gesture start for threshold detection (more forgiving than frame-to-frame)\r\n        const cumulativeDelta = Math.abs(Math.sqrt(pinchSquaredDistance) - Math.sqrt(this._initialPinchSquaredDistance));\r\n        this._shouldStartPinchZoom = this._twoFingerActivityCount < 20 && cumulativeDelta > this.camera.limits.pinchToPanMax;\r\n\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.activeInput = false;\r\n        this._initialPinchSquaredDistance = 0;\r\n        this._pinchCentroid = null;\r\n        super.onButtonUp(_evt);\r\n    }\r\n\r\n    public override onLostFocus(): void {\r\n        this._initialPinchSquaredDistance = 0;\r\n        this._pinchCentroid = null;\r\n        super.onLostFocus();\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/Limits/geospatialLimits.d.ts

@@ -7,7 +7,7 @@ export declare class GeospatialLimits {
     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 */
+    /**  Gets the maximum pitch angle (angle from horizon) -- Pi/2 means looking at horizon */
     pitchMax: number;
     /** Gets the minimum yaw angle (rotation around up axis) */
     yawMin: number;
@@ -39,4 +39,12 @@ export declare class GeospatialLimits {
     get planetRadius(): number;
     /** Sets the planet radius and updates the radius limits to maintain current altitude */
     set planetRadius(value: number);
+    /**
+     * Clamps a zoom distance to respect the radius limits.
+     * @param zoomDistance The requested zoom distance (positive = zoom in, negative = zoom out)
+     * @param currentRadius The current camera radius
+     * @param distanceToTarget Optional distance to the zoom target point (used for zoom-in clamping)
+     * @returns The clamped zoom distance
+     */
+    clampZoomDistance(zoomDistance: number, currentRadius: number, distanceToTarget?: number): number;
 }

package/Cameras/Limits/geospatialLimits.js

@@ -7,12 +7,12 @@ export class GeospatialLimits {
      * @param planetRadius The radius of the planet
      */
     constructor(planetRadius) {
-        this._radiusMin = Epsilon;
+        this._radiusMin = 10;
         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 maximum pitch angle (angle from horizon) -- Pi/2 means looking at horizon */
+        this.pitchMax = Math.PI / 2 - Epsilon;
         /** Gets the minimum yaw angle (rotation around up axis) */
         this.yawMin = -Infinity;
         /** Gets the maximum yaw angle (rotation around up axis) */
@@ -24,6 +24,7 @@ export class GeospatialLimits {
          */
         this.pinchToPanMax = 20;
         this._planetRadius = planetRadius;
+        this.radiusMax = planetRadius * 4;
     }
     get radiusMin() {
         return this._radiusMin;
@@ -53,5 +54,24 @@ export class GeospatialLimits {
     set planetRadius(value) {
         this._planetRadius = value;
     }
+    /**
+     * Clamps a zoom distance to respect the radius limits.
+     * @param zoomDistance The requested zoom distance (positive = zoom in, negative = zoom out)
+     * @param currentRadius The current camera radius
+     * @param distanceToTarget Optional distance to the zoom target point (used for zoom-in clamping)
+     * @returns The clamped zoom distance
+     */
+    clampZoomDistance(zoomDistance, currentRadius, distanceToTarget) {
+        if (zoomDistance > 0) {
+            // Zooming IN - don't zoom past the surface or below radiusMin
+            const maxZoomIn = (distanceToTarget ?? currentRadius) - this._radiusMin;
+            return Math.min(zoomDistance, Math.max(0, maxZoomIn));
+        }
+        else {
+            // Zooming OUT - don't exceed radiusMax
+            const maxZoomOut = this._radiusMax - currentRadius;
+            return Math.max(zoomDistance, -Math.max(0, maxZoomOut));
+        }
+    }
 }
 //# sourceMappingURL=geospatialLimits.js.map

package/Cameras/Limits/geospatialLimits.js.map

@@ -1 +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;IAuBzB;;OAEG;IACH,YAAY,YAAoB;QAxBxB,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,IAAW,SAAS;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,IAAW,SAAS,CAAC,KAAa;QAC9B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC5B,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;IAC5B,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;IAC/B,CAAC;CACJ","sourcesContent":["import { Epsilon } from \"../../Maths/math.constants\";\r\n/**\r\n * Limits for geospatial camera\r\n */\r\nexport class GeospatialLimits {\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\r\n     */\r\n    constructor(planetRadius: number) {\r\n        this._planetRadius = planetRadius;\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\r\n     */\r\n    public set radiusMin(value: number) {\r\n        this._radiusMin = value;\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\r\n     */\r\n    public set radiusMax(value: number) {\r\n        this._radiusMax = value;\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    }\r\n}\r\n"]}
+{"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;IAuBzB;;OAEG;IACH,YAAY,YAAoB;QAxBxB,eAAU,GAAW,EAAE,CAAC;QACxB,eAAU,GAAW,QAAQ,CAAC;QAEtC,mGAAmG;QAC5F,aAAQ,GAAW,OAAO,CAAC;QAElC,0FAA0F;QACnF,aAAQ,GAAW,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC;QAEhD,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;QAClC,IAAI,CAAC,SAAS,GAAG,YAAY,GAAG,CAAC,CAAC;IACtC,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;IAC5B,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;IAC5B,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;IAC/B,CAAC;IAED;;;;;;OAMG;IACI,iBAAiB,CAAC,YAAoB,EAAE,aAAqB,EAAE,gBAAyB;QAC3F,IAAI,YAAY,GAAG,CAAC,EAAE,CAAC;YACnB,8DAA8D;YAC9D,MAAM,SAAS,GAAG,CAAC,gBAAgB,IAAI,aAAa,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC;YACxE,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;QAC1D,CAAC;aAAM,CAAC;YACJ,uCAAuC;YACvC,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,GAAG,aAAa,CAAC;YACnD,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC;QAC5D,CAAC;IACL,CAAC;CACJ","sourcesContent":["import { Epsilon } from \"../../Maths/math.constants\";\r\n/**\r\n * Limits for geospatial camera\r\n */\r\nexport class GeospatialLimits {\r\n    private _planetRadius: number;\r\n    private _radiusMin: number = 10;\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/2 means looking at horizon */\r\n    public pitchMax: number = Math.PI / 2 - Epsilon;\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\r\n     */\r\n    constructor(planetRadius: number) {\r\n        this._planetRadius = planetRadius;\r\n        this.radiusMax = planetRadius * 4;\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\r\n     */\r\n    public set radiusMin(value: number) {\r\n        this._radiusMin = value;\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\r\n     */\r\n    public set radiusMax(value: number) {\r\n        this._radiusMax = value;\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    }\r\n\r\n    /**\r\n     * Clamps a zoom distance to respect the radius limits.\r\n     * @param zoomDistance The requested zoom distance (positive = zoom in, negative = zoom out)\r\n     * @param currentRadius The current camera radius\r\n     * @param distanceToTarget Optional distance to the zoom target point (used for zoom-in clamping)\r\n     * @returns The clamped zoom distance\r\n     */\r\n    public clampZoomDistance(zoomDistance: number, currentRadius: number, distanceToTarget?: number): number {\r\n        if (zoomDistance > 0) {\r\n            // Zooming IN - don't zoom past the surface or below radiusMin\r\n            const maxZoomIn = (distanceToTarget ?? currentRadius) - this._radiusMin;\r\n            return Math.min(zoomDistance, Math.max(0, maxZoomIn));\r\n        } else {\r\n            // Zooming OUT - don't exceed radiusMax\r\n            const maxZoomOut = this._radiusMax - currentRadius;\r\n            return Math.max(zoomDistance, -Math.max(0, maxZoomOut));\r\n        }\r\n    }\r\n}\r\n"]}

package/Cameras/geospatialCamera.d.ts

@@ -1,5 +1,6 @@
 import { GeospatialCameraInputsManager } from "./geospatialCameraInputsManager.js";
 import { Vector3, Matrix } from "../Maths/math.vector.js";
+import type { Vector2 } from "../Maths/math.vector.js";
 import { Camera } from "./camera.js";
 import type { Scene } from "../scene.js";
 import type { MeshPredicate } from "../Culling/ray.core.js";
@@ -146,4 +147,26 @@ export declare class GeospatialCamera extends Camera {
     attachControl(noPreventDefault?: boolean): void;
     detachControl(): void;
 }
+/**
+ * Compute the lookAt direction vector from yaw and pitch angles at a given center point.
+ * This is the forward formula used by GeospatialCamera._setOrientation.
+ * @param yaw - The yaw angle in radians (0 = north, π/2 = east)
+ * @param pitch - The pitch angle in radians (0 = looking at planet center, π/2 = looking at horizon)
+ * @param center - The center point on the globe
+ * @param useRightHandedSystem - Whether the scene uses a right-handed coordinate system
+ * @param result - The vector to store the result in
+ * @returns The normalized lookAt direction vector (same as result)
+ */
+export declare function ComputeLookAtFromYawPitchToRef(yaw: number, pitch: number, center: Vector3, useRightHandedSystem: boolean, result: Vector3): Vector3;
+/**
+ * Given a lookAt direction and center, compute the yaw and pitch angles that would produce that lookAt.
+ * This is the inverse of ComputeLookAtFromYawPitchToRef.
+ * @param lookAt - The normalized lookAt direction vector
+ * @param center - The center point on the globe
+ * @param useRightHandedSystem - Whether the scene uses a right-handed coordinate system
+ * @param currentYaw - The current yaw value to use as fallback when pitch is near 0 (looking straight down/up)
+ * @param result - The Vector2 to store the result in (x = yaw, y = pitch)
+ * @returns The result Vector2
+ */
+export declare function ComputeYawPitchFromLookAtToRef(lookAt: Vector3, center: Vector3, useRightHandedSystem: boolean, currentYaw: number, result: Vector2): Vector2;
 export {};

package/Cameras/geospatialCamera.js

@@ -1,5 +1,5 @@
 import { GeospatialCameraInputsManager } from "./geospatialCameraInputsManager.js";
-import { Vector3, Matrix, TmpVectors } from "../Maths/math.vector.js";
+import { Vector3, Matrix, TmpVectors, Quaternion } from "../Maths/math.vector.js";
 import { Epsilon } from "../Maths/math.constants.js";
 import { Camera } from "./camera.js";
 import { GeospatialLimits } from "./Limits/geospatialLimits.js";
@@ -114,26 +114,26 @@ export class GeospatialCamera extends Camera {
         this._checkLimits();
         // Refresh local basis at center (treat these as read-only for the whole call)
         ComputeLocalBasisToRefs(this._center, this._tempEast, this._tempNorth, this._tempUp);
-        // Trig
-        const yawScale = this._scene.useRightHandedSystem ? 1 : -1;
-        const cosYaw = Math.cos(this._yaw * yawScale);
-        const sinYaw = Math.sin(this._yaw * yawScale);
-        const sinPitch = Math.sin(this._pitch); // horizontal weight
-        const cosPitch = Math.cos(this._pitch); // vertical weight (toward center)
-        // Temps
-        const horiz = TmpVectors.Vector3[0];
-        const t1 = TmpVectors.Vector3[1];
-        const t2 = TmpVectors.Vector3[2];
-        const right = TmpVectors.Vector3[3];
-        // horizontalDirection = North*cosYaw + East*sinYaw  (avoids mutating _temp basis vectors)
-        horiz.copyFrom(this._tempNorth).scaleInPlace(cosYaw).addInPlace(t1.copyFrom(this._tempEast).scaleInPlace(sinYaw));
-        // look = horiz*sinPitch - Up*cosPitch
-        this._lookAtVector.copyFrom(horiz).scaleInPlace(sinPitch).addInPlace(t2.copyFrom(this._tempUp).scaleInPlace(-cosPitch)).normalize(); // keep it unit
+        // Compute lookAt from yaw/pitch
+        ComputeLookAtFromYawPitchToRef(this._yaw, this._pitch, this._center, this._scene.useRightHandedSystem, this._lookAtVector);
         // Build an orthonormal up aligned with geocentric Up
-        // right = normalize(cross(upRef, look))
+        // When looking straight down (pitch ≈ 0), lookAt is parallel to Up, so use the horizontal direction as the camera's up.
+        const right = TmpVectors.Vector3[10];
         Vector3.CrossToRef(this._tempUp, this._lookAtVector, right);
+        if (right.lengthSquared() < Epsilon) {
+            // Looking straight down (or up) - use quaternion rotation to compute horiz
+            const horiz = TmpVectors.Vector3[11];
+            const yawScale = this._scene.useRightHandedSystem ? 1 : -1;
+            const yawQuat = TmpVectors.Quaternion[1];
+            Quaternion.RotationAxisToRef(this._tempUp, this._yaw * yawScale, yawQuat);
+            this._tempNorth.rotateByQuaternionToRef(yawQuat, horiz);
+            // right = cross(horiz, lookAt)
+            Vector3.CrossToRef(horiz, this._lookAtVector, right);
+        }
+        right.normalize();
         // up = normalize(cross(look, right))
         Vector3.CrossToRef(this._lookAtVector, right, this.upVector);
+        this.upVector.normalize();
         // Position = center - look * radius  (preserve unit look)
         this._tempVect.copyFrom(this._lookAtVector).scaleInPlace(-this._radius);
         this._tempPosition.copyFrom(this._center).addInPlace(this._tempVect);
@@ -334,21 +334,8 @@ export class GeospatialCamera extends Camera {
         if (Math.abs(zoomDelta) < Epsilon) {
             return 0;
         }
-        if (zoomDelta > 0) {
-            // Zooming IN - respect radiusMin as distance to surface
-            if (pickedPoint) {
-                const pickDistance = Vector3Distance(this._position, pickedPoint);
-                // Don't zoom past the picked surface point + radiusMin
-                const maxZoomToSurface = pickDistance - this.limits.radiusMin;
-                return Math.min(zoomDelta, Math.max(0, maxZoomToSurface));
-            }
-            return zoomDelta;
-        }
-        else {
-            // Zooming OUT - respect radiusMax
-            const maxZoomOut = this.limits.radiusMax - this._radius;
-            return Math.max(zoomDelta, -Math.max(0, maxZoomOut));
-        }
+        const distanceToTarget = pickedPoint ? Vector3Distance(this._position, pickedPoint) : undefined;
+        return this.limits.clampZoomDistance(zoomDelta, this._radius, distanceToTarget);
     }
     zoomToPoint(targetPoint, distance) {
         const newRadius = this._getCenterAndRadiusFromZoomToPoint(targetPoint, distance, this._tempCenter);
@@ -398,8 +385,16 @@ export class GeospatialCamera extends Camera {
                 const dotProduct = Vector3Dot(this._lookAtVector, centerToOrigin);
                 // Only update if the center is looking toward the origin (dot product > 0) to avoid a center on the opposite side of globe
                 if (dotProduct > 0) {
-                    const newRadius = Vector3Distance(this.position, newCenter.pickedPoint);
-                    this._setOrientation(this._yaw, this._pitch, newRadius, newCenter.pickedPoint);
+                    // Compute the new radius as distance from camera position to new center
+                    const newRadius = Vector3Distance(this._position, newCenter.pickedPoint);
+                    // Only update if the new center is in front of the camera
+                    if (newRadius > Epsilon) {
+                        // Compute yaw/pitch that correspond to current lookAt at new center
+                        const yawPitch = TmpVectors.Vector2[0];
+                        ComputeYawPitchFromLookAtToRef(this._lookAtVector, newCenter.pickedPoint, this._scene.useRightHandedSystem, this._yaw, yawPitch);
+                        // Call _setOrientation with the computed yaw/pitch and new center
+                        this._setOrientation(yawPitch.x, yawPitch.y, newRadius, newCenter.pickedPoint);
+                    }
                 }
             }
         }
@@ -437,4 +432,84 @@ export class GeospatialCamera extends Camera {
         this.inputs.detachElement();
     }
 }
+/**
+ * Compute the lookAt direction vector from yaw and pitch angles at a given center point.
+ * This is the forward formula used by GeospatialCamera._setOrientation.
+ * @param yaw - The yaw angle in radians (0 = north, π/2 = east)
+ * @param pitch - The pitch angle in radians (0 = looking at planet center, π/2 = looking at horizon)
+ * @param center - The center point on the globe
+ * @param useRightHandedSystem - Whether the scene uses a right-handed coordinate system
+ * @param result - The vector to store the result in
+ * @returns The normalized lookAt direction vector (same as result)
+ */
+export function ComputeLookAtFromYawPitchToRef(yaw, pitch, center, useRightHandedSystem, result) {
+    const east = TmpVectors.Vector3[0];
+    const north = TmpVectors.Vector3[1];
+    const up = TmpVectors.Vector3[2];
+    ComputeLocalBasisToRefs(center, east, north, up);
+    const sinPitch = Math.sin(pitch);
+    const cosPitch = Math.cos(pitch);
+    // Use quaternion rotation to compute horiz = rotate(north, up, yaw * yawScale)
+    const yawScale = useRightHandedSystem ? 1 : -1;
+    const yawQuat = TmpVectors.Quaternion[0];
+    Quaternion.RotationAxisToRef(up, yaw * yawScale, yawQuat);
+    const horiz = TmpVectors.Vector3[3];
+    north.rotateByQuaternionToRef(yawQuat, horiz);
+    // lookAt = horiz * sinPitch - up * cosPitch
+    const t2 = TmpVectors.Vector3[4];
+    result.copyFrom(horiz).scaleInPlace(sinPitch).addInPlace(t2.copyFrom(up).scaleInPlace(-cosPitch));
+    return result.normalize();
+}
+/**
+ * Given a lookAt direction and center, compute the yaw and pitch angles that would produce that lookAt.
+ * This is the inverse of ComputeLookAtFromYawPitchToRef.
+ * @param lookAt - The normalized lookAt direction vector
+ * @param center - The center point on the globe
+ * @param useRightHandedSystem - Whether the scene uses a right-handed coordinate system
+ * @param currentYaw - The current yaw value to use as fallback when pitch is near 0 (looking straight down/up)
+ * @param result - The Vector2 to store the result in (x = yaw, y = pitch)
+ * @returns The result Vector2
+ */
+export function ComputeYawPitchFromLookAtToRef(lookAt, center, useRightHandedSystem, currentYaw, result) {
+    // Compute local basis at center
+    const east = TmpVectors.Vector3[6];
+    const north = TmpVectors.Vector3[7];
+    const up = TmpVectors.Vector3[8];
+    ComputeLocalBasisToRefs(center, east, north, up);
+    // lookAt = horiz*sinPitch - up*cosPitch
+    // where horiz = rotate(north, up, yaw * yawScale) via quaternion
+    //
+    // The vertical component of lookAt (along up) gives us cosPitch:
+    // lookAt · up = -cosPitch
+    const lookDotUp = Vector3Dot(lookAt, up);
+    const cosPitch = -lookDotUp;
+    // Clamp cosPitch to valid range to avoid NaN from acos
+    const clampedCosPitch = Clamp(cosPitch, -1, 1);
+    const pitch = Math.acos(clampedCosPitch);
+    // The horizontal component gives us yaw
+    // lookHorizontal = lookAt + up*cosPitch = horiz*sinPitch
+    const lookHorizontal = TmpVectors.Vector3[9];
+    const scaledUp = TmpVectors.Vector3[10];
+    scaledUp.copyFrom(up).scaleInPlace(cosPitch);
+    lookHorizontal.copyFrom(lookAt).addInPlace(scaledUp);
+    const sinPitch = Math.sin(pitch);
+    if (Math.abs(sinPitch) < Epsilon) {
+        // Looking straight down or up, yaw is undefined - keep current
+        result.x = currentYaw;
+        result.y = pitch;
+        return result;
+    }
+    // horiz = lookHorizontal / sinPitch
+    const horiz = lookHorizontal.scaleInPlace(1 / sinPitch);
+    // The quaternion rotation produces: horiz = rotate(north, up, angle)
+    // This is equivalent to: horiz = north*cos(angle) + cross(up, north)*sin(angle) = north*cos(angle) - east*sin(angle)
+    // (since cross(up, north) = -east in our basis)
+    // So: cosYaw = horiz · north, sinYaw = -(horiz · east)
+    const cosYaw = Vector3Dot(horiz, north);
+    const sinYaw = -Vector3Dot(horiz, east);
+    const yawScale = useRightHandedSystem ? 1 : -1;
+    result.x = Math.atan2(sinYaw, cosYaw) * yawScale;
+    result.y = pitch;
+    return result;
+}
 //# sourceMappingURL=geospatialCamera.js.map