@openglobus/og 0.18.0 → 0.18.2

package/{src/control/MouseNavigation.ts → lib/js/control/MouseNavigation.js}

@@ -1,57 +1,22 @@
 import * as math from "../math";
-import {Control, IControlParams} from "./Control";
-import {input} from "../input/input";
-import {Key} from "../Lock";
-import {LonLat} from "../LonLat";
-import {Mat4} from "../math/Mat4";
-import {Quat} from "../math/Quat";
-import {Ray} from "../math/Ray";
-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 { Control } from "./Control";
+import { input } from "../input/input";
+import { Key } from "../Lock";
+import { LonLat } from "../LonLat";
+import { Mat4 } from "../math/Mat4";
+import { Quat } from "../math/Quat";
+import { Ray } from "../math/Ray";
+import { Sphere } from "../bv/Sphere";
+import { Vec3 } from "../math/Vec3";
 /**
  * Mouse planet camera dragging control.
  */
 export class MouseNavigation extends Control {
-    protected grabbedPoint: Vec3;
-    protected _eye0: Vec3;
-    protected pointOnEarth: Vec3;
-    protected earthUp: Vec3;
-    public 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;
-    public minSlope: number;
-    protected _wheelDirection: number;
-    protected _keyLock: Key;
-    protected _deactivate = false;
-    protected _shiftBusy = false;
-
-    constructor(options: IMouseNavigationParams = {}) {
+    constructor(options = {}) {
         super(options);
-
+        this._deactivate = false;
+        this._shiftBusy = false;
         this._name = "mouseNavigation";
-
         this.grabbedPoint = new Vec3();
         this._eye0 = new Vec3();
         this.pointOnEarth = new Vec3();
@@ -60,59 +25,39 @@ export class MouseNavigation extends Control {
         this.grabbedSpheroid = new Sphere();
         this.qRot = new Quat();
         this.scaleRot = 0.0;
-
         this.distDiff = 0.3;
         this.stepsCount = 8;
         this.stepsForward = null;
         this.stepIndex = 0;
-
         this._lmbDoubleClickActive = true;
-
         this.minSlope = options.minSlope || 0.1;
-
         this._wheelDirection = +1;
-
         this._keyLock = new Key();
     }
-
-    static getMovePointsFromPixelTerrain(cam: PlanetCamera, planet: Planet, stepsCount: number, delta: number, point: Vec2, forward: boolean, dir?: Vec3 | null): IStepForward[] | undefined {
-        const steps: IStepForward[] = [];
-
-        let eye = cam.eye.clone(),
-            n = cam._b.clone(),
-            u = cam._r.clone(),
-            v = cam._u.clone();
-
+    static getMovePointsFromPixelTerrain(cam, planet, stepsCount, delta, point, forward, dir) {
+        const steps = [];
+        let eye = cam.eye.clone(), n = cam._b.clone(), u = cam._r.clone(), v = cam._u.clone();
         let a = planet.getCartesianFromPixelTerrain(point);
-
         if (!a) {
-            a = planet.getCartesianFromPixelTerrain(planet.renderer!.handler.getCenter());
+            a = planet.getCartesianFromPixelTerrain(planet.renderer.handler.getCenter());
         }
-
         if (a) {
             if (!dir) {
                 dir = Vec3.sub(a, cam.eye).normalize();
             }
-
             let d = (delta * cam.eye.distance(a)) / stepsCount;
-
             if (forward) {
                 d = -1.25 * d;
-            } else {
+            }
+            else {
                 d *= 2;
             }
-
             const scaled_n = n.scaleTo(d);
-
             const slope = dir.dot(cam.eye.normal().negate());
-
             if (slope >= 0.1) {
                 const grabbedSpheroid = new Sphere();
                 grabbedSpheroid.radius = a.length();
-
-                let rotArr = [],
-                    eyeArr = [];
-
+                let rotArr = [], eyeArr = [];
                 let breaked = false;
                 for (let i = 0; i < stepsCount; i++) {
                     eye.addA(scaled_n);
@@ -120,12 +65,12 @@ export class MouseNavigation extends Control {
                     eyeArr[i] = eye.clone();
                     if (b) {
                         rotArr[i] = new Mat4().rotateBetweenVectors(a.normal(), b.normal());
-                    } else {
+                    }
+                    else {
                         breaked = true;
                         break;
                     }
                 }
-
                 if (!breaked) {
                     for (let i = 0; i < stepsCount; i++) {
                         let rot = rotArr[i];
@@ -136,7 +81,8 @@ export class MouseNavigation extends Control {
                             n: rot.mulVec3(n)
                         };
                     }
-                } else {
+                }
+                else {
                     eye = cam.eye.clone();
                     for (let i = 0; i < stepsCount; i++) {
                         steps[i] = {
@@ -147,7 +93,8 @@ export class MouseNavigation extends Control {
                         };
                     }
                 }
-            } else {
+            }
+            else {
                 for (let i = 0; i < stepsCount; i++) {
                     steps[i] = {
                         eye: eye.addA(dir.scaleTo(-d)).clone(),
@@ -157,12 +104,10 @@ export class MouseNavigation extends Control {
                     };
                 }
             }
-
             return steps;
         }
     }
-
-    public override onactivate() {
+    onactivate() {
         if (this.renderer) {
             this.renderer.events.on("mousewheel", this.onMouseWheel, this);
             this.renderer.events.on("lhold", this.onMouseLeftButtonDown, this);
@@ -174,14 +119,12 @@ export class MouseNavigation extends Control {
             this.renderer.events.on("mousemove", this.onMouseMove, this);
             this.renderer.events.on("mouseleave", this.onMouseLeave, this);
             this.renderer.events.on("mouseenter", this.onMouseEnter, this);
-
             if (this._lmbDoubleClickActive) {
                 this.renderer.events.on("ldblclick", this.onMouseLeftButtonDoubleClick, this);
             }
         }
     }
-
-    public override ondeactivate() {
+    ondeactivate() {
         if (this.renderer) {
             this.renderer.events.off("mousewheel", this.onMouseWheel);
             this.renderer.events.off("lhold", this.onMouseLeftButtonDown);
@@ -195,165 +138,127 @@ export class MouseNavigation extends Control {
             this.renderer.events.off("mouseenter", this.onMouseEnter);
         }
     }
-
-    public activateDoubleClickZoom() {
+    activateDoubleClickZoom() {
         if (!this._lmbDoubleClickActive) {
             this._lmbDoubleClickActive = true;
             this.renderer && this.renderer.events.on("ldblclick", this.onMouseLeftButtonDoubleClick, this);
         }
     }
-
-    public deactivateDoubleClickZoom() {
+    deactivateDoubleClickZoom() {
         if (this._lmbDoubleClickActive) {
             this._lmbDoubleClickActive = false;
             this.renderer && this.renderer.events.off("ldblclick", this.onMouseLeftButtonDoubleClick);
         }
     }
-
-    protected onMouseEnter(e: IMouseState) {
-        const renderEvents = this.renderer!.events;
+    onMouseEnter(e) {
+        const renderEvents = this.renderer.events;
         if (renderEvents.isKeyPressed(input.KEY_ALT)) {
             renderEvents.releaseKeys();
         }
-
-        renderEvents.updateButtonsStates(e.sys!.buttons);
+        renderEvents.updateButtonsStates(e.sys.buttons);
         if (renderEvents.mouseState.leftButtonDown) {
-            this.renderer!.handler.canvas!.classList.add("ogGrabbingPoiner");
-        } else {
-            this.renderer!.handler.canvas!.classList.remove("ogGrabbingPoiner");
+            this.renderer.handler.canvas.classList.add("ogGrabbingPoiner");
+        }
+        else {
+            this.renderer.handler.canvas.classList.remove("ogGrabbingPoiner");
         }
     }
-
-    protected onMouseLeave() {
-        if (this.renderer!.events.mouseState.leftButtonDown) {
+    onMouseLeave() {
+        if (this.renderer.events.mouseState.leftButtonDown) {
             this.scaleRot = 0;
         }
-        this.renderer!.handler.canvas!.classList.remove("ogGrabbingPoiner");
+        this.renderer.handler.canvas.classList.remove("ogGrabbingPoiner");
     }
-
-    protected onMouseWheel(e: IMouseState) {
+    onMouseWheel(e) {
         if (this.stepIndex) {
             return;
         }
-
-        this.planet!.stopFlying();
-
+        this.planet.stopFlying();
         this.stopRotation();
-
         this._deactivate = true;
-
-        this.planet!.layerLock.lock(this._keyLock);
+        this.planet.layerLock.lock(this._keyLock);
         //this.planet!.terrainLock.lock(this._keyLock);
-        this.planet!._normalMapCreator.lock(this._keyLock);
-
-        this.stepsForward = MouseNavigation.getMovePointsFromPixelTerrain(
-            this.planet!.camera,
-            this.planet!,
-            this.stepsCount,
-            this.distDiff,
-            e.pos,
-            e.wheelDelta > 0,
-            e.direction
-        ) || null;
-
+        this.planet._normalMapCreator.lock(this._keyLock);
+        this.stepsForward = MouseNavigation.getMovePointsFromPixelTerrain(this.planet.camera, this.planet, this.stepsCount, this.distDiff, e.pos, e.wheelDelta > 0, e.direction) || null;
         this._wheelDirection = e.wheelDelta;
-
         if (this.stepsForward) {
             this.stepIndex = this.stepsCount;
         }
     }
-
-    public override oninit() {
+    oninit() {
         this.activate();
         if (this.renderer) {
             this.renderer.events.on("keyfree", input.KEY_ALT, this.onShiftFree, this);
             this.renderer.events.on("keyfree", input.KEY_PRINTSCREEN, this.onShiftFree, this);
         }
     }
-
-    protected onMouseLeftButtonDoubleClick(e: IMouseState) {
-        this.planet!.stopFlying();
+    onMouseLeftButtonDoubleClick(e) {
+        this.planet.stopFlying();
         this.stopRotation();
-        const p = this.planet!.getCartesianFromPixelTerrain(e.pos);
+        const p = this.planet.getCartesianFromPixelTerrain(e.pos);
         if (p) {
-            const cam = this.planet!.camera;
-            let maxAlt = cam.maxAltitude + this.planet!.ellipsoid.polarSize;
-            let minAlt = cam.minAltitude + this.planet!.ellipsoid.polarSize;
+            const cam = this.planet.camera;
+            let maxAlt = cam.maxAltitude + this.planet.ellipsoid.polarSize;
+            let minAlt = cam.minAltitude + this.planet.ellipsoid.polarSize;
             const camAlt = cam.eye.length();
-            const g = this.planet!.ellipsoid.cartesianToLonLat(p);
+            const g = this.planet.ellipsoid.cartesianToLonLat(p);
             if (camAlt > maxAlt || camAlt < minAlt) {
-                this.planet!.flyLonLat(new LonLat(g.lon, g.lat))
+                this.planet.flyLonLat(new LonLat(g.lon, g.lat));
                 return;
             }
-
-            if (this.renderer!.events.isKeyPressed(input.KEY_ALT)) {
-                this.planet!.flyLonLat(
-                    new LonLat(g.lon, g.lat, cam.eye.distance(p) * 2.0)
-                );
-            } else {
-                this.planet!.flyLonLat(
-                    new LonLat(g.lon, g.lat, cam.eye.distance(p) * 0.57)
-                );
+            if (this.renderer.events.isKeyPressed(input.KEY_ALT)) {
+                this.planet.flyLonLat(new LonLat(g.lon, g.lat, cam.eye.distance(p) * 2.0));
+            }
+            else {
+                this.planet.flyLonLat(new LonLat(g.lon, g.lat, cam.eye.distance(p) * 0.57));
             }
         }
     }
-
-    protected onMouseLeftButtonClick() {
+    onMouseLeftButtonClick() {
         if (this._active) {
-            this.renderer!.handler.canvas!.classList.add("ogGrabbingPoiner");
-            this.grabbedPoint = this.planet!.getCartesianFromMouseTerrain()!;
+            this.renderer.handler.canvas.classList.add("ogGrabbingPoiner");
+            this.grabbedPoint = this.planet.getCartesianFromMouseTerrain();
             if (this.grabbedPoint) {
-                this._eye0.copy(this.planet!.camera.eye);
+                this._eye0.copy(this.planet.camera.eye);
                 this.grabbedSpheroid.radius = this.grabbedPoint.length();
                 this.stopRotation();
             }
         }
     }
-
-    public stopRotation() {
+    stopRotation() {
         this.qRot.clear();
-        this.planet!.layerLock.free(this._keyLock);
-        this.planet!.terrainLock.free(this._keyLock);
-        this.planet!._normalMapCreator.free(this._keyLock);
+        this.planet.layerLock.free(this._keyLock);
+        this.planet.terrainLock.free(this._keyLock);
+        this.planet._normalMapCreator.free(this._keyLock);
     }
-
-    protected onMouseLeftButtonUp(e: IMouseState) {
-        this.renderer!.handler.canvas!.classList.remove("ogGrabbingPoiner");
+    onMouseLeftButtonUp(e) {
+        this.renderer.handler.canvas.classList.remove("ogGrabbingPoiner");
         if (e.x === e.prev_x && e.y === e.prev_y) {
             this.scaleRot = 0.0;
         }
     }
-
-    protected onMouseLeftButtonDown(e: IMouseState) {
+    onMouseLeftButtonDown(e) {
         if (this._active) {
             if (!this.grabbedPoint) {
                 return;
             }
-
-            this.planet!.stopFlying();
-
+            this.planet.stopFlying();
             if (e.moving) {
-                let cam = this.planet!.camera;
-
+                let cam = this.planet.camera;
                 if (cam.slope > 0.2) {
                     const targetPoint = new Ray(cam.eye, e.direction).hitSphere(this.grabbedSpheroid);
                     if (targetPoint) {
                         this.scaleRot = 1.0;
-                        this.qRot = Quat.getRotationBetweenVectors(
-                            targetPoint.normal(),
-                            this.grabbedPoint.normal()
-                        );
+                        this.qRot = Quat.getRotationBetweenVectors(targetPoint.normal(), this.grabbedPoint.normal());
                         let rot = this.qRot;
                         cam.eye = rot.mulVec3(cam.eye);
                         cam._u = rot.mulVec3(cam._u);
                         cam._r = rot.mulVec3(cam._r);
                         cam._b = rot.mulVec3(cam._b);
                     }
-                } else {
-                    let p0 = this.grabbedPoint,
-                        p1 = Vec3.add(p0, cam._r),
-                        p2 = Vec3.add(p0, p0.normal());
-
+                }
+                else {
+                    let p0 = this.grabbedPoint, p1 = Vec3.add(p0, cam._r), p2 = Vec3.add(p0, p0.normal());
                     let px = new Vec3();
                     if (new Ray(cam.eye, e.direction).hitPlane(p0, p1, p2, px) === Ray.INSIDE) {
                         cam.eye = this._eye0.addA(px.subA(p0).negate());
@@ -362,21 +267,18 @@ export class MouseNavigation extends Control {
             }
         }
     }
-
-    protected onMouseRightButtonClick(e: IMouseState) {
+    onMouseRightButtonClick(e) {
         this.stopRotation();
-        this.planet!.stopFlying();
-        this.pointOnEarth = this.planet!.getCartesianFromPixelTerrain(e.pos)!;
+        this.planet.stopFlying();
+        this.pointOnEarth = this.planet.getCartesianFromPixelTerrain(e.pos);
         if (this.pointOnEarth) {
             this.earthUp = this.pointOnEarth.normal();
         }
     }
-
-    protected onMouseRightButtonDown(e: IMouseState) {
-        const cam = this.planet!.camera;
-
+    onMouseRightButtonDown(e) {
+        const cam = this.planet.camera;
         if (this.pointOnEarth && e.moving) {
-            this.renderer!.controlsBag.scaleRot = 1.0;
+            this.renderer.controlsBag.scaleRot = 1.0;
             let l = (0.5 / cam.eye.distance(this.pointOnEarth)) * (cam._lonLat.height < 5.0 ? 5.0 : cam._lonLat.height) * math.RADIANS;
             if (l > 0.007) {
                 l = 0.007;
@@ -385,62 +287,54 @@ export class MouseNavigation extends Control {
             cam.rotateVertical(l * (e.y - e.prev_y), this.pointOnEarth, this.minSlope);
         }
     }
-
-    public onShiftFree() {
+    onShiftFree() {
         this._shiftBusy = false;
     }
-
-    protected onMouseMove(e: IMouseState) {
-        if (this._active && this.renderer!.events.isKeyPressed(input.KEY_ALT)) {
+    onMouseMove(e) {
+        if (this._active && this.renderer.events.isKeyPressed(input.KEY_ALT)) {
             if (!this._shiftBusy) {
                 this._shiftBusy = true;
                 this.onMouseRightButtonClick(e);
             }
-
             this.onMouseRightButtonDown(e);
         }
     }
-
-    protected onDraw() {
+    onDraw() {
         if (this._active) {
-            const r = this.renderer!;
-            const cam = this.planet!.camera;
+            const r = this.renderer;
+            const cam = this.planet.camera;
             let prevEye = cam.eye.clone();
-
             if (this.stepIndex) {
                 r.controlsBag.scaleRot = 1.0;
-                const sf = this.stepsForward![this.stepsCount - this.stepIndex--];
-
-                let maxAlt = cam.maxAltitude + this.planet!.ellipsoid.polarSize;
-                let minAlt = cam.minAltitude + this.planet!.ellipsoid.polarSize;
+                const sf = this.stepsForward[this.stepsCount - this.stepIndex--];
+                let maxAlt = cam.maxAltitude + this.planet.ellipsoid.polarSize;
+                let minAlt = cam.minAltitude + this.planet.ellipsoid.polarSize;
                 const camAlt = sf.eye.length();
                 if (camAlt > maxAlt || camAlt < minAlt && this._wheelDirection > 0) {
                     this._wheelDirection = +1;
                     return;
                 }
-
                 cam.eye = sf.eye;
                 cam._u = sf.v;
                 cam._r = sf.u;
                 cam._b = sf.n;
-            } else {
+            }
+            else {
                 if (this._deactivate) {
                     this._deactivate = false;
-
-                    this.planet!.layerLock.free(this._keyLock);
-                    this.planet!.terrainLock.free(this._keyLock);
-                    this.planet!._normalMapCreator.free(this._keyLock);
+                    this.planet.layerLock.free(this._keyLock);
+                    this.planet.terrainLock.free(this._keyLock);
+                    this.planet._normalMapCreator.free(this._keyLock);
                 }
             }
-
             if (r.events.mouseState.leftButtonDown || !this.scaleRot) {
                 return;
             }
-
             this.scaleRot -= this.inertia;
             if (this.scaleRot <= 0.0) {
                 this.scaleRot = 0.0;
-            } else {
+            }
+            else {
                 r.controlsBag.scaleRot = this.scaleRot;
                 let rot = this.qRot
                     .slerp(Quat.IDENTITY, 1.0 - this.scaleRot * this.scaleRot * this.scaleRot)
@@ -453,15 +347,15 @@ export class MouseNavigation extends Control {
                 cam._r = rot.mulVec3(cam._r);
                 cam._b = rot.mulVec3(cam._b);
             }
-
             if (cam.eye.distance(prevEye) / cam.getAltitude() > 0.01) {
-                this.planet!.layerLock.lock(this._keyLock);
-                this.planet!.terrainLock.lock(this._keyLock);
-                this.planet!._normalMapCreator.lock(this._keyLock);
-            } else {
-                this.planet!.layerLock.free(this._keyLock);
-                this.planet!.terrainLock.free(this._keyLock);
-                this.planet!._normalMapCreator.free(this._keyLock);
+                this.planet.layerLock.lock(this._keyLock);
+                this.planet.terrainLock.lock(this._keyLock);
+                this.planet._normalMapCreator.lock(this._keyLock);
+            }
+            else {
+                this.planet.layerLock.free(this._keyLock);
+                this.planet.terrainLock.free(this._keyLock);
+                this.planet._normalMapCreator.free(this._keyLock);
             }
         }
     }

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

@@ -0,0 +1,44 @@
+import { Sphere } from "../bv/Sphere";
+import { Key } from "../Lock";
+import { Quat } from "../math/Quat";
+import { Vec3 } from "../math/Vec3";
+import { Control, IControlParams } from "./Control";
+import { IStepForward } from "./MouseNavigation";
+interface IMouseWheelZoomControl extends IControlParams {
+    minSlope?: number;
+}
+export declare class MouseWheelZoomControl 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;
+    protected minSlope: number;
+    protected _keyLock: Key;
+    protected _deactivate: boolean;
+    protected _move: number;
+    constructor(options?: IMouseWheelZoomControl);
+    oninit(): void;
+    /**
+     * Planet zoom in.
+     * @public
+     */
+    zoomIn(): void;
+    /**
+     * Planet zoom out.
+     * @public
+     */
+    zoomOut(): void;
+    stopRotation(): void;
+    stopZoom(): void;
+    protected _draw(): void;
+}
+export {};