@openglobus/og 0.23.0 → 0.24.0

package/lib/js/Globe.d.ts

@@ -33,7 +33,6 @@ export interface IGlobeParams {
     transitionOpacityEnabled?: boolean;
     terrain?: EmptyTerrain;
     controls?: Control[];
-    useEarthNavigation?: boolean;
     minSlope?: number;
     sun?: {
         active?: boolean;

package/lib/js/Globe.js

@@ -1,7 +1,6 @@
 // #StandWithUkraine
 import { CompassButton } from "./control/CompassButton";
 import { EarthCoordinates } from "./control/EarthCoordinates";
-import { EarthNavigation } from "./control/EarthNavigation";
 import { EmptyTerrain } from "./terrain/EmptyTerrain";
 import { Handler } from "./webgl/Handler";
 import { isEmpty } from "./utils/shared";
@@ -178,7 +177,7 @@ class Globe {
         else {
             this.planet.addControls([
                 new ZoomControl(),
-                options.useEarthNavigation ? new EarthNavigation() : new MouseNavigation({ minSlope: options.minSlope }),
+                new MouseNavigation(),
                 new TouchNavigation(),
                 new EarthCoordinates(),
                 new ScaleControl(),
@@ -262,6 +261,9 @@ class Globe {
                 t.appendChild(this.$inner);
             }
         }
+        else {
+            console.warn(`Target container not found. Provided target: ${target}`);
+        }
     }
     detach() {
         if (this.$target) {

package/lib/js/Popup.js

@@ -117,7 +117,7 @@ class Popup extends View {
             let look = cart.sub(cam.eye), v = Math.sqrt((f + g) * (f + g) - f * f);
             if (v > look.length() && cam.getForward().dot(look.normalize()) > 0.0) {
                 this.el.style.display = "block";
-                this.setScreen(cam.project(cart));
+                this.setScreen(cam.project3v(cart));
             }
             else {
                 this.el.style.display = "none";

package/lib/js/camera/Camera.d.ts

@@ -6,6 +6,7 @@ import { Renderer } from "../renderer/Renderer";
 import { Vec2, NumberArray2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
 import { Sphere } from "../bv/Sphere";
+import { Quat } from "../math/Quat";
 type CameraEvents = ["viewchange", "moveend"];
 export interface ICameraParams {
     eye?: Vec3;
@@ -89,22 +90,28 @@ declare class Camera {
     protected _normalMatrix: Mat3;
     /**
      * Camera right vector.
-     * @public
+     * @protected
      * @type {Vec3}
      */
     _r: Vec3;
     /**
      * Camera up vector.
-     * @public
+     * @protected
      * @type {Vec3}
      */
     _u: Vec3;
     /**
      * Camera backward vector.
-     * @public
+     * @protected
      * @type {Vec3}
      */
     _b: Vec3;
+    /**
+     * Camera forward vector.
+     * @protected
+     * @type {Vec3}
+     */
+    _f: Vec3;
     protected _pr: Vec3;
     protected _pu: Vec3;
     protected _pb: Vec3;
@@ -208,23 +215,40 @@ declare class Camera {
      */
     slide(du: number, dv: number, dn: number): void;
     /**
-     * Roll the camera to the angle in degrees
+     * Roll the camera to the angle in radians
+     * @public
+     * @param {number} angle - Delta roll angle in radians
+     */
+    setRoll(angle: number): void;
+    /**
+     * Pitch the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta roll angle in degrees
+     * @param {number} angle - Delta pitch angle in radians
      */
-    roll(angle: number): void;
+    setPitch(angle: number): void;
     /**
-     * Pitch the camera to the angle in degrees
+     * Yaw the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta pitch angle in degrees
+     * @param {number} angle - Delta yaw angle in radians
+     */
+    setYaw(angle: number): void;
+    setPitchYawRoll(pitch: number, yaw: number, roll: number): void;
+    getPitch(): number;
+    getYaw(): number;
+    getRoll(): number;
+    /**
+     * Returns camera quaternion
      */
-    pitch(angle: number): void;
+    getRotation(): Quat;
+    setRotation(rot: Quat, up?: Vec3, right?: Vec3, back?: Vec3): void;
+    rotate(rot: Quat): void;
     /**
-     * Yaw the camera to the angle in degrees
+     * Returns normal vector direction to the unprojected screen point from camera eye
      * @public
-     * @param {number} angle - Delta yaw angle in degrees
+     * @param {Vec2} pos - Screen X coordinate
+     * @returns {Vec3} - Direction vector
      */
-    yaw(angle: number): void;
+    unproject2v(pos: Vec2): Vec3;
     /**
      * Returns normal vector direction to the unprojected screen point from camera eye
      * @public
@@ -239,7 +263,16 @@ declare class Camera {
      * @param {Vec3} v - Cartesian 3d coordinates
      * @returns {Vec2} - Screen point coordinates
      */
-    project(v: Vec3): Vec2;
+    project3v(v: Vec3): Vec2;
+    /**
+     * Gets projected 3d point to the 2d screen coordinates
+     * @public
+     * @param {number} x - X coordinate
+     * @param {number} y - Y coordinate
+     * @param {number} z - Z coordinate
+     * @returns {Vec2} - Screen point coordinates
+     */
+    project(x: number, y: number, z: number): Vec2;
     /**
      * Rotates camera around center point
      * @public
@@ -249,7 +282,7 @@ declare class Camera {
      * @param {Vec3} [center] - Point that the camera rotates around
      * @param {Vec3} [up] - Camera up vector
      */
-    rotateAround(angle: number, isArc?: boolean, center?: Vec3 | null, up?: Vec3 | null): void;
+    rotateAround(angle: number, isArc?: boolean, center?: Vec3, up?: Vec3): void;
     /**
      * Rotates camera around center point by horizontal.
      * @public
@@ -259,7 +292,7 @@ declare class Camera {
      * @param {Vec3} [center] - Point that the camera rotates around.
      * @param {Vec3} [up] - Camera up vector.
      */
-    rotateHorizontal(angle: number, isArc?: boolean, center?: Vec3 | null, up?: Vec3 | null): void;
+    rotateHorizontal(angle: number, isArc?: boolean, center?: Vec3, up?: Vec3): void;
     /**
      * Rotates camera around center point by vertical.
      * @param {number} angle - Rotation angle in radians.

package/lib/js/camera/Camera.js

@@ -7,6 +7,7 @@ import { Vec2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
 import { Vec4 } from "../math/Vec4";
 import { Quat } from "../math/Quat";
+import { RADIANS } from "../math";
 const EVENT_NAMES = [
     /**
      * When camera has been updated.
@@ -50,6 +51,7 @@ class Camera {
         this._r = new Vec3(1.0, 0.0, 0.0);
         this._u = new Vec3(0.0, 1.0, 0.0);
         this._b = new Vec3(0.0, 0.0, 1.0);
+        this._f = this._b.negateTo();
         // Previous frame values
         this._pr = this._r.clone();
         this._pu = this._u.clone();
@@ -147,7 +149,7 @@ class Camera {
         return this._r.negateTo();
     }
     getForward() {
-        return this._b.negateTo();
+        return this._f.clone();
     }
     getBackward() {
         return this._b.clone();
@@ -218,7 +220,7 @@ class Camera {
         this._tanViewAngle_hradOneByHeight =
             this._tanViewAngle_hrad * this.renderer.handler._oneByHeight;
         let c = this.renderer.handler.canvas;
-        this._projSizeConst = Math.min(c.clientWidth < 512 ? 512 : c.clientWidth, c.clientHeight < 512 ? 512 : c.clientHeight) / (angle * math.RADIANS);
+        this._projSizeConst = Math.min(c.clientWidth < 512 ? 512 : c.clientWidth, c.clientHeight < 512 ? 512 : c.clientHeight) / (angle * RADIANS);
         for (let i = 0, len = this.frustums.length; i < len; i++) {
             this.frustums[i].setProjectionMatrix(angle, aspect, this.frustums[i].near, this.frustums[i].far);
         }
@@ -264,6 +266,7 @@ class Camera {
         this._b.normalize();
         this._r.normalize();
         this._u.copy(this._b.cross(this._r));
+        this._f.set(-this._b.x, -this._b.y, -this._b.z);
         return this;
     }
     /**
@@ -276,6 +279,7 @@ class Camera {
         this._b.set(this.eye.x - look.x, this.eye.y - look.y, this.eye.z - look.z);
         this._r.copy((up || this._u).cross(this._b));
         this._b.normalize();
+        this._f.set(-this._b.x, -this._b.y, -this._b.z);
         this._r.normalize();
         this._u.copy(this._b.cross(this._r));
     }
@@ -292,41 +296,82 @@ class Camera {
         this.eye.z += du * this._r.z + dv * this._u.z + dn * this._b.z;
     }
     /**
-     * Roll the camera to the angle in degrees
+     * Roll the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta roll angle in degrees
+     * @param {number} angle - Delta roll angle in radians
      */
-    roll(angle) {
-        let cs = Math.cos(math.RADIANS * angle);
-        let sn = Math.sin(math.RADIANS * angle);
+    setRoll(angle) {
+        let cs = Math.cos(angle);
+        let sn = Math.sin(angle);
         let t = this._r.clone();
         this._r.set(cs * t.x - sn * this._u.x, cs * t.y - sn * this._u.y, cs * t.z - sn * this._u.z);
         this._u.set(sn * t.x + cs * this._u.x, sn * t.y + cs * this._u.y, sn * t.z + cs * this._u.z);
     }
     /**
-     * Pitch the camera to the angle in degrees
+     * Pitch the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta pitch angle in degrees
+     * @param {number} angle - Delta pitch angle in radians
      */
-    pitch(angle) {
-        let cs = Math.cos(math.RADIANS * angle);
-        let sn = Math.sin(math.RADIANS * angle);
-        let t = this._b.clone();
+    setPitch(angle) {
+        let cs = Math.cos(angle);
+        let sn = Math.sin(angle);
+        let t = this._b;
         this._b.set(cs * t.x - sn * this._u.x, cs * t.y - sn * this._u.y, cs * t.z - sn * this._u.z);
         this._u.set(sn * t.x + cs * this._u.x, sn * t.y + cs * this._u.y, sn * t.z + cs * this._u.z);
     }
     /**
-     * Yaw the camera to the angle in degrees
+     * Yaw the camera to the angle in radians
      * @public
-     * @param {number} angle - Delta yaw angle in degrees
+     * @param {number} angle - Delta yaw angle in radians
      */
-    yaw(angle) {
-        let cs = Math.cos(math.RADIANS * angle);
-        let sn = Math.sin(math.RADIANS * angle);
-        let t = this._r.clone();
+    setYaw(angle) {
+        let cs = Math.cos(angle);
+        let sn = Math.sin(angle);
+        let t = this._r;
         this._r.set(cs * t.x - sn * this._b.x, cs * t.y - sn * this._b.y, cs * t.z - sn * this._b.z);
         this._b.set(sn * t.x + cs * this._b.x, sn * t.y + cs * this._b.y, sn * t.z + cs * this._b.z);
     }
+    setPitchYawRoll(pitch, yaw, roll) {
+        let qRot = new Quat();
+        qRot.setPitchYawRoll(pitch, yaw, roll);
+        this.setRotation(qRot);
+    }
+    getPitch() {
+        return this.getRotation().getPitch();
+    }
+    getYaw() {
+        return this.getRotation().getYaw();
+    }
+    getRoll() {
+        return this.getRotation().getRoll();
+    }
+    /**
+     * Returns camera quaternion
+     */
+    getRotation() {
+        return Quat.getLookRotation(this._f, this._u).conjugate();
+    }
+    setRotation(rot, up, right, back) {
+        rot.mulVec3Res(up || new Vec3(0, 1, 0), this._u);
+        rot.mulVec3Res(right || new Vec3(1, 0, 0), this._r);
+        rot.mulVec3Res(back || new Vec3(0, 0, 1), this._b);
+        this._f.set(-this._b.x, -this._b.y, -this._b.z);
+    }
+    rotate(rot) {
+        rot.mulVec3Res(this._u, this._u);
+        rot.mulVec3Res(this._r, this._r);
+        rot.mulVec3Res(this._b, this._b);
+        this._f.set(-this._b.x, -this._b.y, -this._b.z);
+    }
+    /**
+     * Returns normal vector direction to the unprojected screen point from camera eye
+     * @public
+     * @param {Vec2} pos - Screen X coordinate
+     * @returns {Vec3} - Direction vector
+     */
+    unproject2v(pos) {
+        return this.unproject(pos.x, pos.y);
+    }
     /**
      * Returns normal vector direction to the unprojected screen point from camera eye
      * @public
@@ -346,8 +391,19 @@ class Camera {
      * @param {Vec3} v - Cartesian 3d coordinates
      * @returns {Vec2} - Screen point coordinates
      */
-    project(v) {
-        let r = this.frustums[0].projectionViewMatrix.mulVec4(v.toVec4()), c = this.renderer.handler.canvas;
+    project3v(v) {
+        return this.project(v.x, v.y, v.z);
+    }
+    /**
+     * Gets projected 3d point to the 2d screen coordinates
+     * @public
+     * @param {number} x - X coordinate
+     * @param {number} y - Y coordinate
+     * @param {number} z - Z coordinate
+     * @returns {Vec2} - Screen point coordinates
+     */
+    project(x, y, z) {
+        let r = this.frustums[0].projectionViewMatrix.mulVec4(new Vec4(x, y, z, 1.0)), c = this.renderer.handler.canvas;
         return new Vec2((1 + r.x / r.w) * c.width * 0.5, (1 - r.y / r.w) * c.height * 0.5);
     }
     /**
@@ -359,17 +415,15 @@ class Camera {
      * @param {Vec3} [center] - Point that the camera rotates around
      * @param {Vec3} [up] - Camera up vector
      */
-    rotateAround(angle, isArc, center, up) {
-        center = center || Vec3.ZERO;
-        up = up || Vec3.UP;
-        let rot = new Mat4().setRotation(isArc ? this._u : up, angle);
-        let tr = new Mat4().setIdentity().translate(center);
-        let ntr = new Mat4().setIdentity().translate(center.negateTo());
-        let trm = tr.mul(rot).mul(ntr);
+    rotateAround(angle, isArc = false, center = Vec3.ZERO, up = Vec3.UP) {
+        up = isArc ? this._u : up;
+        let rot = Mat4.getRotation(angle, up);
+        let trm = Mat4.getRotationAroundPoint(angle, center, up);
         this.eye = trm.mulVec3(this.eye);
         this._u = rot.mulVec3(this._u).normalize();
         this._r = rot.mulVec3(this._r).normalize();
         this._b = rot.mulVec3(this._b).normalize();
+        this._f.set(-this._b.x, -this._b.y, -this._b.z);
     }
     /**
      * Rotates camera around center point by horizontal.

package/lib/js/camera/PlanetCamera.d.ts

@@ -228,7 +228,20 @@ declare class PlanetCamera extends Camera {
     checkFly(): void;
     checkTerrainCollision(): Vec3 | undefined;
     getSurfaceVisibleDistance(d: number): number;
+    /**
+     * should be yje same as getYaw
+     */
     getHeading(): number;
     isVisible(poi: Vec3): boolean;
+    getPitch(): number;
+    /**
+     * should be the same as getHeading
+     */
+    getYaw(): number;
+    getRoll(): number;
+    setPitch(a: number): void;
+    setYaw(a: number): void;
+    setRoll(a: number): void;
+    setPitchYawRoll(pitch: number, yaw: number, roll: number): void;
 }
 export { PlanetCamera };

package/lib/js/camera/PlanetCamera.js

@@ -7,6 +7,7 @@ import { Mat4 } from "../math/Mat4";
 import { Quat } from "../math/Quat";
 import { Ray } from "../math/Ray";
 import { Vec3 } from "../math/Vec3";
+import { RADIANS } from "../math";
 /**
  * Planet camera.
  * @class
@@ -167,7 +168,7 @@ class PlanetCamera extends Camera {
         let up = right.cross(direction).normalize();
         let _h = Math.max(Math.abs(up.dot(northWest)), Math.abs(up.dot(southEast)), Math.abs(up.dot(northEast)), Math.abs(up.dot(southWest)));
         let _w = Math.max(Math.abs(right.dot(northWest)), Math.abs(right.dot(southEast)), Math.abs(right.dot(northEast)), Math.abs(right.dot(southWest)));
-        let tanPhi = Math.tan(this._viewAngle * math.RADIANS * 0.5);
+        let tanPhi = Math.tan(this._viewAngle * RADIANS * 0.5);
         let tanTheta = this._aspect * tanPhi;
         let d = Math.max(_w / tanTheta, _h / tanPhi);
         center.normalize();
@@ -329,6 +330,7 @@ class PlanetCamera extends Camera {
         this._framesArr = [];
         this._framesCounter = -1;
         this._frameCallback = null;
+        this.planet.stopDragging();
     }
     /**
      * Returns camera is flying.
@@ -345,7 +347,7 @@ class PlanetCamera extends Camera {
      * @param {boolean} [spin] - If its true rotates around globe spin.
      */
     rotateLeft(angle, spin) {
-        this.rotateHorizontal(angle * math.RADIANS, spin !== true, Vec3.ZERO);
+        this.rotateHorizontal(angle, spin !== true, Vec3.ZERO);
         this.update();
     }
     /**
@@ -355,7 +357,7 @@ class PlanetCamera extends Camera {
      * @param {boolean} [spin] - If its true rotates around globe spin.
      */
     rotateRight(angle, spin) {
-        this.rotateHorizontal(-angle * math.RADIANS, spin !== true, Vec3.ZERO);
+        this.rotateHorizontal(-angle, spin !== true, Vec3.ZERO);
         this.update();
     }
     /**
@@ -364,7 +366,7 @@ class PlanetCamera extends Camera {
      * @param {number} angle - Rotation angle.
      */
     rotateUp(angle) {
-        this.rotateVertical(angle * math.RADIANS, Vec3.ZERO);
+        this.rotateVertical(angle, Vec3.ZERO);
         this.update();
     }
     /**
@@ -373,7 +375,7 @@ class PlanetCamera extends Camera {
      * @param {number} angle - Rotation angle.
      */
     rotateDown(angle) {
-        this.rotateVertical(-angle * math.RADIANS, Vec3.ZERO);
+        this.rotateVertical(-angle, Vec3.ZERO);
         this.update();
     }
     rotateVertical(angle, center, minSlope = 0) {
@@ -398,6 +400,7 @@ class PlanetCamera extends Camera {
                 this._u = u;
                 this._r = r;
                 this._b = b;
+                this._f.set(-b.x, -b.y, -b.z);
             }
         }
         else {
@@ -405,6 +408,7 @@ class PlanetCamera extends Camera {
             this._u = u;
             this._r = r;
             this._b = b;
+            this._f.set(-b.x, -b.y, -b.z);
         }
     }
     /**
@@ -421,6 +425,7 @@ class PlanetCamera extends Camera {
             this._r = this._framesArr[c].u;
             this._u = this._framesArr[c].v;
             this._b = this._framesArr[c].n;
+            this._f.set(-this._b.x, -this._b.y, -this._b.z);
             if (this._frameCallback) {
                 this._frameCallback();
             }
@@ -449,6 +454,9 @@ class PlanetCamera extends Camera {
         let R = this.planet.ellipsoid.equatorialSize;
         return R * Math.acos(R / (R + this._lonLat.height + d));
     }
+    /**
+     * should be yje same as getYaw
+     */
     getHeading() {
         let u = this.eye.getNormal();
         let f = Vec3.proj_b_to_plane(this.slope >= 0.97 ? this.getUp() : this.getForward(), u).normalize(), n = Vec3.proj_b_to_plane(Vec3.NORTH, u).normalize();
@@ -462,5 +470,44 @@ class PlanetCamera extends Camera {
         let e = this.eye.length();
         return this.eye.distance(poi) < Math.sqrt(e * e - this.planet.ellipsoid.equatorialSizeSqr);
     }
+    getPitch() {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        return qFrame.conjugate().inverse().mul(this.getRotation()).getPitch();
+    }
+    /**
+     * should be the same as getHeading
+     */
+    getYaw() {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        return qFrame.conjugate().inverse().mul(this.getRotation()).getYaw();
+    }
+    getRoll() {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        return qFrame.conjugate().inverse().mul(this.getRotation()).getRoll();
+    }
+    setPitch(a) {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        let qRot = new Quat();
+        qRot.setPitchYawRoll(a, this.getYaw(), this.getRoll(), qFrame);
+        this.setRotation(qRot);
+    }
+    setYaw(a) {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        let qRot = new Quat();
+        qRot.setPitchYawRoll(this.getYaw(), a, this.getRoll(), qFrame);
+        this.setRotation(qRot);
+    }
+    setRoll(a) {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        let qRot = new Quat();
+        qRot.setPitchYawRoll(this.getPitch(), this.getYaw(), a, qFrame);
+        this.setRotation(qRot);
+    }
+    setPitchYawRoll(pitch, yaw, roll) {
+        let qFrame = this.planet.getFrameRotation(this.eye);
+        let qRot = new Quat();
+        qRot.setPitchYawRoll(pitch, yaw, roll, qFrame).conjugate();
+        this.setRotation(qRot);
+    }
 }
 export { PlanetCamera };

package/lib/js/control/CameraLock.js

@@ -139,7 +139,7 @@ export class CameraLock extends Control {
     _deactivateNav() {
         if (this.renderer && this.renderer.controls.mouseNavigation) {
             this.renderer.controls.mouseNavigation.deactivate();
-            this.renderer.controls.mouseNavigation.stopRotation();
+            this.renderer.controls.mouseNavigation.stop();
         }
         if (this.renderer && this.renderer.controls.simpleNavigation) {
             this.renderer.controls.simpleNavigation.deactivate();

package/lib/js/control/DebugInfo.js

@@ -2,6 +2,7 @@ import { Control } from "./Control";
 import { Dialog } from "../ui/Dialog";
 import { ToggleButton } from "../ui/ToggleButton";
 import { CanvasTiles } from "../layer/CanvasTiles";
+import { DEGREES } from "../math";
 const ICON_LOCK_BUTTON_SVG = `<?xml version="1.0" encoding="utf-8"?>
 <!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
 <svg fill="#000000" width="800px" height="800px" viewBox="-7.5 0 32 32" version="1.1" xmlns="http://www.w3.org/2000/svg">
@@ -195,16 +196,6 @@ export class DebugInfo extends Control {
                         return "";
                     }
                 },
-                {
-                    label: "height/alt, m",
-                    frame: () => `<div style="width:190px">${(p.camera._lonLat.height).toFixed(2) +
-                        " / " +
-                        (p.camera.getAltitude()).toFixed(2)}</div>`
-                },
-                {
-                    label: "cam.slope",
-                    frame: () => p.camera.slope.toFixed(3)
-                },
                 {
                     label: "lodSize",
                     frame: () => Math.round(p.lodSize)
@@ -220,6 +211,35 @@ export class DebugInfo extends Control {
                 {
                     label: "-------------------------"
                 },
+                {
+                    label: "Pitch, deg",
+                    frame: () => (p.camera.getPitch() * DEGREES).toFixed(2)
+                },
+                {
+                    label: "Yaw, deg",
+                    frame: () => (p.camera.getYaw() * DEGREES).toFixed(2)
+                },
+                {
+                    label: "Roll, deg",
+                    frame: () => (p.camera.getRoll() * DEGREES).toFixed(2)
+                },
+                {
+                    label: "Lon, Lat",
+                    frame: () => `<div style="width:190px">${(p.camera._lonLat.lon).toFixed(7)}, ${(p.camera._lonLat.lon).toFixed(7)}</div>`
+                },
+                {
+                    label: "height/alt, m",
+                    frame: () => `<div style="width:190px">${(p.camera._lonLat.height).toFixed(2) +
+                        " / " +
+                        (p.camera.getAltitude()).toFixed(2)}</div>`
+                },
+                {
+                    label: "cam.slope",
+                    frame: () => p.camera.slope.toFixed(3)
+                },
+                {
+                    label: "-------------------------"
+                },
                 {
                     label: "_renderCompleted / renderCompletedActivated",
                     frame: () => `${p._renderCompleted} / ${p._renderCompletedActivated}`

package/lib/js/control/KeyboardNavigation.js

@@ -71,7 +71,7 @@ export class KeyboardNavigation extends Control {
     onCameraLookUp() {
         let cam = this.planet.camera;
         if (this.renderer.events.isKeyPressed(input.KEY_SHIFT)) {
-            cam.pitch(15 / this.renderer.handler.deltaTime);
+            cam.setPitch(15 / this.renderer.handler.deltaTime);
         }
         else {
             cam.rotateVertical((cam.getAltitude() / 3000000) * math.RADIANS, Vec3.ZERO);
@@ -80,7 +80,7 @@ export class KeyboardNavigation extends Control {
     onCameraLookDown() {
         let cam = this.planet.camera;
         if (this.renderer.events.isKeyPressed(input.KEY_SHIFT)) {
-            cam.pitch(-15 / this.renderer.handler.deltaTime);
+            cam.setPitch(-15 / this.renderer.handler.deltaTime);
         }
         else {
             cam.rotateVertical((-cam.getAltitude() / 3000000) * math.RADIANS, Vec3.ZERO);
@@ -89,7 +89,7 @@ export class KeyboardNavigation extends Control {
     onCameraLookLeft() {
         let cam = this.planet.camera;
         if (this.renderer.events.isKeyPressed(input.KEY_SHIFT)) {
-            cam.roll(15 / this.renderer.handler.deltaTime);
+            cam.setRoll(15 / this.renderer.handler.deltaTime);
         }
         else {
             cam.rotateHorizontal((cam.getAltitude() / 3000000) * math.RADIANS);
@@ -98,7 +98,7 @@ export class KeyboardNavigation extends Control {
     onCameraLookRight() {
         let cam = this.planet.camera;
         if (this.renderer.events.isKeyPressed(input.KEY_SHIFT)) {
-            cam.roll(-15 / this.renderer.handler.deltaTime);
+            cam.setRoll(-15 / this.renderer.handler.deltaTime);
         }
         else {
             cam.rotateHorizontal((-cam.getAltitude() / 3000000) * math.RADIANS);
@@ -107,7 +107,7 @@ export class KeyboardNavigation extends Control {
     onCameraTurnLeft() {
         let cam = this.planet.camera;
         if (this.renderer.events.isKeyPressed(input.KEY_SHIFT)) {
-            cam.yaw(15 / this.renderer.handler.deltaTime);
+            cam.setYaw(15 / this.renderer.handler.deltaTime);
         }
         else {
             cam.rotateHorizontal((cam.getAltitude() / 3000000) * math.RADIANS);
@@ -116,7 +116,7 @@ export class KeyboardNavigation extends Control {
     onCameraTurnRight() {
         let cam = this.planet.camera;
         if (this.renderer.events.isKeyPressed(input.KEY_SHIFT)) {
-            cam.yaw(-15 / this.renderer.handler.deltaTime);
+            cam.setYaw(-15 / this.renderer.handler.deltaTime);
         }
         else {
             cam.rotateHorizontal((-cam.getAltitude() / 3000000) * math.RADIANS, false, Vec3.ZERO);
@@ -135,9 +135,9 @@ export class KeyboardNavigation extends Control {
         }
     }
     onCameraRollLeft() {
-        this.planet.camera.roll(-15 / this.renderer.handler.deltaTime);
+        this.planet.camera.setRoll(-15 / this.renderer.handler.deltaTime);
     }
     onCameraRollRight() {
-        this.planet.camera.roll(15 / this.renderer.handler.deltaTime);
+        this.planet.camera.setRoll(15 / this.renderer.handler.deltaTime);
     }
 }