@openglobus/og 0.22.2 → 0.24.0

package/lib/js/control/CameraLock.js

@@ -0,0 +1,216 @@
+import { Control } from "./Control";
+import { Quat } from "../math/Quat";
+import { Vec3 } from "../math/Vec3";
+import { createEvents } from "../Events";
+import { input } from "../input/input";
+import { RADIANS } from "../math";
+const MIN_LOCK_DISTANCE = 0.001;
+const MIN_VIEW_DISTANCE = 120.0;
+let qOrientationRot = new Quat();
+const t = 0.08;
+const CameraLockEvents = ["lockview", "unlockview"];
+export class CameraLock extends Control {
+    constructor(options = {}) {
+        super(options);
+        this._onLockViewDraw = () => {
+            if (this.renderer && this._lockEntity) {
+                if (this._isFromTheBack) {
+                    // let cam = this.planet.camera;
+                    // let vehPos = this._lockEntity.getCartesian(),
+                    //     vehDir = this._lockEntity.direction;
+                    // let currPos = vehPos.sub(this._viewDir.scaleTo(this._lockDistance));
+                    // let dh = new Vec3();
+                    // let currPosProj = new Plane(vehPos, vehPos.normal()).getProjectionPoint(currPos, dh);
+                    // let projViewDir = vehPos.sub(currPosProj);
+                    // Quat.getRotationBetweenVectorsRes(projViewDir.normal(), vehDir, qOrientationRot);
+                    // let rot = qOrientationRot.slerp(Quat.IDENTITY, 1.0 - t).normalize();
+                    // let projViewDir_t = rot.mulVec3(projViewDir.normal());
+                    // projViewDir = projViewDir_t.scale(projViewDir.length());
+                    // let newPos = vehPos.add(dh).sub(projViewDir);
+                    // this._viewDir = vehPos.sub(newPos).normalize();
+                    // cam.set(newPos, vehPos, vehPos.normal());
+                    // cam.update();
+                }
+                else {
+                    this.renderer.activeCamera.viewDistance(this._lockEntity.getAbsoluteCartesian(), this._lockDistance);
+                }
+            }
+        };
+        this._onMouseWheel = (e) => {
+            if (this.renderer && this._lockEntity) {
+                if (this._isFromTheBack) {
+                    //...
+                }
+                else {
+                    let d = this.renderer.activeCamera.eye.distance(this._lockEntity.getAbsoluteCartesian());
+                    this._lockDistance -= 0.33 * d * Math.sign(e.wheelDelta);
+                    if (this._lockDistance < MIN_LOCK_DISTANCE) {
+                        this._lockDistance = MIN_LOCK_DISTANCE;
+                    }
+                    this.renderer.activeCamera.viewDistance(this._lockEntity.getAbsoluteCartesian(), this._lockDistance);
+                }
+            }
+        };
+        this._onMouseMove = (ms) => {
+            if (this._lockEntity && this.renderer) {
+                if (ms.rightButtonDown || this.renderer.events.isKeyPressed(input.KEY_ALT)) {
+                    let p = this._lockEntity.getAbsoluteCartesian(), cam = this.renderer.activeCamera, l = 0.5 / RADIANS;
+                    if (l > 0.007)
+                        l = 0.007;
+                    if (this.planet) {
+                        cam.rotateHorizontal(l * (ms.x - ms.prev_x), false, p, p.isZero() ? Vec3.UP : p.normal());
+                    }
+                    else {
+                        cam.rotateHorizontal(l * (ms.x - ms.prev_x), false, p, Vec3.UP);
+                    }
+                    cam.rotateVertical(l * (ms.y - ms.prev_y), p);
+                    this._viewDir = p.sub(cam.eye).normalize();
+                }
+            }
+        };
+        this.events = createEvents(CameraLockEvents);
+        this._name = "CameraLock";
+        this.planet = options.planet || null;
+        this._lockDistance = 0;
+        this._isFromTheBack = false;
+        this._lockEntity = null;
+        this._viewDir = new Vec3(0, 0, 0);
+    }
+    onactivate() {
+        if (this.renderer) {
+        }
+    }
+    ondeactivate() {
+        if (this.renderer) {
+            this.unlockView();
+        }
+    }
+    oninit() {
+        this.activate();
+        if (this.renderer) {
+        }
+    }
+    flyCartesian(cartesian, dist = MIN_VIEW_DISTANCE) {
+        if (cartesian.isZero() || !this.renderer) {
+            return;
+        }
+        this.unlockView();
+        if (this.planet) {
+            let cam = this.planet.camera;
+            if (this.isVisibleDistance(cartesian)) {
+                cam.flyDistance(cartesian, dist);
+            }
+            if (cam.eye.distance(cartesian) < 1000000.0) {
+                cam.flyDistance(cartesian, dist);
+            }
+            else {
+                cam.viewDistance(cartesian, dist);
+            }
+        }
+        else {
+            this.renderer.activeCamera.viewDistance(cartesian, dist);
+        }
+    }
+    lockView(entity, fromTheBack = false) {
+        if (!this.renderer)
+            return;
+        this._lockDistance = this._getDistance(entity, this._lockEntity);
+        this._isFromTheBack = fromTheBack;
+        this._deactivateLockViewEvents();
+        this._lockEntity = entity;
+        let cam = this.renderer.activeCamera;
+        if (this.planet) {
+            this.planet.camera.stopFlying();
+        }
+        cam.viewDistance(entity.getAbsoluteCartesian(), this._lockDistance);
+        this._deactivateNav();
+        this._activateLockViewEvents();
+        this._viewDir = entity.getAbsoluteCartesian().sub(cam.eye).normalize();
+        this.events.dispatch(this.events.lockview, this._lockEntity, fromTheBack);
+    }
+    _activateNav() {
+        if (this.renderer && this.renderer.controls.mouseNavigation) {
+            this.renderer.controls.mouseNavigation.activate();
+        }
+        if (this.renderer && this.renderer.controls.simpleNavigation) {
+            this.renderer.controls.simpleNavigation.activate();
+        }
+    }
+    _deactivateNav() {
+        if (this.renderer && this.renderer.controls.mouseNavigation) {
+            this.renderer.controls.mouseNavigation.deactivate();
+            this.renderer.controls.mouseNavigation.stop();
+        }
+        if (this.renderer && this.renderer.controls.simpleNavigation) {
+            this.renderer.controls.simpleNavigation.deactivate();
+        }
+    }
+    unlockView() {
+        if (this._lockEntity) {
+            this._deactivateLockViewEvents();
+            this._activateNav();
+            this.events.dispatch(this.events.unlockview, this._lockEntity);
+            this._lockEntity = null;
+        }
+    }
+    _getCenterDist() {
+        if (this.renderer) {
+            return this.renderer.getDistanceFromPixel(this.renderer.handler.getCenter()) || 0;
+        }
+        return 0;
+    }
+    _getDistance(entity, prevEntity) {
+        if (this.renderer) {
+            let cartesian = entity.getAbsoluteCartesian();
+            let cam = this.renderer.activeCamera;
+            let dist = cam.eye.distance(cartesian);
+            if (prevEntity) {
+                dist = cam.eye.distance(prevEntity.getAbsoluteCartesian());
+            }
+            if (this.isVisibleDistance(cartesian)) {
+                return dist;
+            }
+            if (cam.eye.distance(cartesian) < 1000000.0) {
+                return this._getCenterDist();
+            }
+            else {
+                return MIN_VIEW_DISTANCE;
+            }
+        }
+        return 0;
+    }
+    isVisibleDistance(cart, C = 0.0) {
+        if (this.planet) {
+            let R = this.planet.ellipsoid.equatorialSize;
+            let eye = this.planet.camera.eye;
+            let camDist = eye.distance(cart);
+            return camDist < Math.sqrt(eye.length2() - R * R) + C;
+        }
+        return true;
+    }
+    get lockEntity() {
+        return this._lockEntity;
+    }
+    flyLonLat(lonLat, dist = MIN_VIEW_DISTANCE) {
+        if (this.planet) {
+            let cartesian = this.planet.ellipsoid.lonLatToCartesian(lonLat);
+            this.flyCartesian(cartesian, dist);
+        }
+    }
+    _activateLockViewEvents() {
+        if (this.renderer) {
+            this.renderer.events.on("mousewheel", this._onMouseWheel);
+            this.renderer.events.on("mousemove", this._onMouseMove);
+            this.renderer.events.on("draw", this._onLockViewDraw);
+        }
+    }
+    _deactivateLockViewEvents() {
+        if (this.renderer) {
+            this.renderer.events.off("mousewheel", this._onMouseWheel);
+            this.renderer.events.off("mousemove", this._onMouseMove);
+            if (this._lockEntity) {
+                this.renderer.events.off("draw", this._onLockViewDraw);
+            }
+        }
+    }
+}

package/lib/js/control/Control.js

@@ -62,7 +62,7 @@ export class Control {
             this.renderer = renderer;
             renderer.controls[this.name] = this;
             this.onadd && this.onadd();
-            if (renderer.isInitialized()) {
+            if (renderer.isInitialized() && !this._initialized) {
                 this._initialized = true;
                 this.oninit && this.oninit();
                 if (this.autoActivate) {

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">
@@ -186,14 +187,14 @@ export class DebugInfo extends Control {
                     frame: () => p.getViewExtent().toString()
                 },
                 {
-                    label: "height/alt (km)",
-                    frame: () => `<div style="width:190px">${(p.camera._lonLat.height / 1000.0).toFixed(2) +
-                        " / " +
-                        (p.camera.getAltitude() / 1000.0).toFixed(2)}</div>`
-                },
-                {
-                    label: "cam.slope",
-                    frame: () => p.camera.slope.toFixed(3)
+                    label: "Mouse distance, m",
+                    frame: () => {
+                        let cart = p.getCartesianFromMouseTerrain();
+                        if (cart) {
+                            return p.camera.eye.distance(cart).toFixed(3);
+                        }
+                        return "";
+                    }
                 },
                 {
                     label: "lodSize",
@@ -210,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

@@ -9,7 +9,7 @@ export class KeyboardNavigation extends Control {
     constructor(options = {}) {
         options = options || {};
         super({ name: "KeyboardNavigation", ...options });
-        this.step = options.step || 250;
+        this.step = options.step || 25000;
     }
     onactivate() {
         let r = this.renderer;
@@ -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);
     }
 }

package/lib/js/control/MouseNavigation.d.ts

@@ -1,64 +1,75 @@
 import { Control, IControlParams } from "./Control";
-import { Key } from "../Lock";
+import { IMouseState } from "../renderer/RendererEvents";
 import { Quat } from "../math/Quat";
 import { Sphere } from "../bv/Sphere";
-import { Vec3 } from "../math/Vec3";
 import { Vec2 } from "../math/Vec2";
-import { Planet } from "../scene/Planet";
-import { PlanetCamera } from "../camera/PlanetCamera";
-import { IMouseState } from "../renderer/RendererEvents";
-export interface IStepForward {
-    eye: Vec3;
-    v: Vec3;
-    u: Vec3;
-    n: Vec3;
-}
-interface IMouseNavigationParams extends IControlParams {
-    minSlope?: number;
+import { Vec3 } from "../math/Vec3";
+interface IEarthNavigationParams extends IControlParams {
+    speed?: number;
+    fixedUp?: boolean;
 }
-/**
- * Mouse planet camera dragging control.
- */
 export declare class MouseNavigation extends Control {
-    protected grabbedPoint: Vec3;
-    protected _eye0: Vec3;
-    protected pointOnEarth: Vec3;
-    protected earthUp: Vec3;
-    inertia: number;
-    protected grabbedSpheroid: Sphere;
-    protected qRot: Quat;
-    protected scaleRot: number;
-    protected distDiff: number;
-    protected stepsCount: number;
-    protected stepsForward: IStepForward[] | null;
-    protected stepIndex: number;
-    protected _lmbDoubleClickActive: boolean;
-    minSlope: number;
+    speed: number;
+    force: Vec3;
+    force_h: number;
+    force_v: number;
+    vel: Vec3;
+    vel_h: number;
+    vel_v: number;
+    mass: number;
+    vel_roll: number;
+    force_roll: number;
+    protected _lookPos: Vec3 | undefined;
+    protected _grabbedPoint: Vec3 | null;
+    protected _targetZoomPoint: Vec3 | null;
+    protected _targetDragPoint: Vec3 | null;
+    protected _targetRotationPoint: Vec3 | null;
+    protected _grabbedSphere: Sphere;
     protected _wheelDirection: number;
-    protected _keyLock: Key;
-    protected _deactivate: boolean;
+    protected _currScreenPos: Vec2;
+    protected _tUp: Vec3;
+    protected _tRad: number;
     protected _shiftBusy: boolean;
-    constructor(options?: IMouseNavigationParams);
-    static getMovePointsFromPixelTerrain(cam: PlanetCamera, planet: Planet, stepsCount: number, delta: number, point: Vec2, forward: boolean, dir?: Vec3 | null): IStepForward[] | undefined;
+    protected fixedUp: boolean;
+    protected _curPitch: number;
+    protected _curYaw: number;
+    protected _curRoll: number;
+    protected _rot: Quat;
+    protected _eye0: Vec3;
+    protected _grabbedCameraHeight: number;
+    protected _newEye: Vec3;
+    protected _isTouchPad: boolean;
+    protected _velInertia: number;
+    protected _hold: boolean;
+    protected _prevVel: Vec3;
+    protected _screenPosIsChanged: boolean;
+    protected _rotHDir: number;
+    protected _rotVDir: number;
+    constructor(options?: IEarthNavigationParams);
+    oninit(): void;
     onactivate(): void;
     ondeactivate(): void;
-    activateDoubleClickZoom(): void;
-    deactivateDoubleClickZoom(): void;
-    protected onMouseEnter(e: IMouseState): void;
-    protected onMouseLeave(): void;
-    protected onMouseWheel(e: IMouseState): void;
-    oninit(): void;
-    protected onMouseLeftButtonDoubleClick(e: IMouseState): void;
-    protected onMouseLeftButtonClick(): void;
-    stopRotation(): void;
-    protected onMouseLeftButtonUp(e: IMouseState): void;
-    protected onMouseLeftButtonDown(e: IMouseState): void;
-    protected onMouseRightButtonClick(e: IMouseState): void;
-    protected onMouseRightButtonDown(e: IMouseState): void;
-    onShiftFree(): void;
-    protected onMouseMove(e: IMouseState): void;
     protected onDraw(): void;
-    lockPlanet(skipTerrain?: boolean): void;
-    freePlanet(): void;
+    _onShiftFree: () => void;
+    protected _onMouseMove: (e: IMouseState) => void;
+    protected _onMouseEnter: (e: IMouseState) => void;
+    protected _onMouseLeave: () => void;
+    protected _onRHold: (e: IMouseState) => void;
+    protected _handleRotation(): void;
+    protected _onRDown: (e: IMouseState) => void;
+    protected _getTargetPoint(p: Vec2): Vec3 | null;
+    protected _onMouseWheel: (e: IMouseState) => void;
+    protected _onLDown: (e: IMouseState) => void;
+    protected _onLHold: (e: IMouseState) => void;
+    protected _onLUp: (e: IMouseState) => void;
+    protected _handleDrag(): void;
+    protected _corrRoll(): void;
+    protected _handleZoom(): void;
+    protected _updateVel(): void;
+    protected _updateVel_h(): void;
+    protected _updateVel_v(): void;
+    protected _updateVel_roll(): void;
+    protected get dt(): number;
+    stop(): void;
 }
 export {};