@openglobus/og 0.18.0 → 0.18.2

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

@@ -1,30 +1,11 @@
-import {Control, IControlParams} from "./Control";
-import {LonLat} from "../LonLat";
-import {ITouchState} from "../renderer/RendererEvents";
-import {IMouseState} from "../renderer/RendererEvents";
-import {Quat} from "../math/Quat";
-import {Ray} from "../math/Ray";
-import {Sphere} from "../bv/Sphere";
-import {Vec2} from "../math/Vec2";
-import {Vec3} from "../math/Vec3";
-
-interface Touch {
-    pageX: number;
-    pageY: number;
-}
-
-interface IEarthNavigationParams extends IControlParams {
-
-}
-
+import { Control } from "./Control";
+import { LonLat } from "../LonLat";
+import { Quat } from "../math/Quat";
+import { Ray } from "../math/Ray";
+import { Sphere } from "../bv/Sphere";
+import { Vec2 } from "../math/Vec2";
+import { Vec3 } from "../math/Vec3";
 class TouchExt {
-    public x: number;
-    public y: number;
-    public prev_x: number;
-    public prev_y: number;
-    public grabbedPoint: Vec3 | null;
-    public grabbedSpheroid: Sphere;
-
     constructor() {
         this.x = 0;
         this.y = 0;
@@ -33,32 +14,16 @@ class TouchExt {
         this.grabbedPoint = new Vec3();
         this.grabbedSpheroid = new Sphere();
     }
-
-    public dX(): number {
+    dX() {
         return this.x - this.prev_x;
     }
-
-    public dY(): number {
+    dY() {
         return this.y - this.prev_y;
     }
 }
-
 export class EarthNavigation extends Control {
-    protected grabbedPoint: Vec3 | null;
-    protected grabbedDir: Vec3;
-    public inertia: number;
-    protected grabbedSpheroid: Sphere;
-    protected _vRot: Quat;
-    protected _hRot: Quat;
-    protected _a: number;
-    protected scaleRot: number;
-    protected currState: number;
-    protected positionState: { h: number; max: number; min: number; }[];
-    protected touches: TouchExt[];
-
-    constructor(options: IEarthNavigationParams = {}) {
+    constructor(options = {}) {
         super(options);
-
         this.grabbedPoint = new Vec3();
         this.grabbedDir = new Vec3();
         this.inertia = 0.007;
@@ -69,215 +34,160 @@ export class EarthNavigation extends Control {
         this._a = 0.0;
         this.scaleRot = 0;
         this.currState = 0;
-
         this.positionState = [
-            {h: 17119745.303455353, max: 0.98, min: -0.98},
-            {h: 6866011, max: 0.98, min: -0.98},
-            {h: 3000000, max: 0.98, min: -0.98},
-            {h: 1000000, max: 0.98, min: -0.98},
-            {h: 500000, max: 0.98, min: -0.98}
+            { h: 17119745.303455353, max: 0.98, min: -0.98 },
+            { h: 6866011, max: 0.98, min: -0.98 },
+            { h: 3000000, max: 0.98, min: -0.98 },
+            { h: 1000000, max: 0.98, min: -0.98 },
+            { h: 500000, max: 0.98, min: -0.98 }
         ];
-
         this.touches = [new TouchExt(), new TouchExt()];
     }
-
-    public switchZoomState(wheelDelta: number) {
+    switchZoomState(wheelDelta) {
         this.stopRotation();
-
         if (wheelDelta > 0) {
             this.currState++;
-        } else {
+        }
+        else {
             this.currState--;
         }
-
-        if (this.currState <= 0) this.currState = 0;
-
+        if (this.currState <= 0)
+            this.currState = 0;
         if (this.currState >= this.positionState.length) {
             this.currState = this.positionState.length - 1;
         }
-
-        this.planet!.stopFlying();
-
-        const ll = this.planet!.camera._lonLat;
-
-        this.planet!.flyLonLat(new LonLat(ll.lon, ll.lat, this.positionState[this.currState].h));
+        this.planet.stopFlying();
+        const ll = this.planet.camera._lonLat;
+        this.planet.flyLonLat(new LonLat(ll.lon, ll.lat, this.positionState[this.currState].h));
     }
-
-    protected onMouseWheel(event: IMouseState) {
+    onMouseWheel(event) {
         this.switchZoomState(event.wheelDelta);
     }
-
-    public override oninit() {
+    oninit() {
         this.activate();
     }
-
-    public override onactivate() {
-
-        let r = this.renderer!;
-
+    onactivate() {
+        let r = this.renderer;
         r.events.on("mousewheel", this.onMouseWheel, this);
         r.events.on("lhold", this.onMouseLeftButtonDown, this);
         r.events.on("ldown", this.onMouseLeftButtonClick, this);
         r.events.on("lup", this.onMouseLeftButtonUp, this);
-
         r.events.on("touchstart", this.onTouchStart, this);
         r.events.on("touchend", this.onTouchEnd, this);
         r.events.on("touchmove", this.onTouchMove, this);
-
         r.events.on("draw", this.onDraw, this);
     }
-
-    protected onTouchStart(e: ITouchState) {
-        if (e.sys!.touches.length == 1) {
+    onTouchStart(e) {
+        if (e.sys.touches.length == 1) {
             const t = this.touches[0];
-
-            t.x = e.sys!.touches.item(0)!.pageX - e.sys!.offsetLeft;
-            t.y = e.sys!.touches.item(0)!.pageY - e.sys!.offsetTop;
-            t.prev_x = e.sys!.touches.item(0)!.pageX - e.sys!.offsetLeft;
-            t.prev_y = e.sys!.touches.item(0)!.pageY - e.sys!.offsetTop;
-
+            t.x = e.sys.touches.item(0).pageX - e.sys.offsetLeft;
+            t.y = e.sys.touches.item(0).pageY - e.sys.offsetTop;
+            t.prev_x = e.sys.touches.item(0).pageX - e.sys.offsetLeft;
+            t.prev_y = e.sys.touches.item(0).pageY - e.sys.offsetTop;
             // t.grabbedPoint = this.planet!.getCartesianFromPixelTerrain(t, true);
-            t.grabbedPoint = this.planet!.getCartesianFromPixelTerrain(new Vec2(t.x, t.y)) || null;
-
+            t.grabbedPoint = this.planet.getCartesianFromPixelTerrain(new Vec2(t.x, t.y)) || null;
             if (t.grabbedPoint) {
                 t.grabbedSpheroid.radius = t.grabbedPoint.length();
                 this.stopRotation();
             }
         }
     }
-
-    protected onTouchEnd(e: ITouchState) {
-        if (e.sys!.touches.length == 0) {
+    onTouchEnd(e) {
+        if (e.sys.touches.length == 0) {
             this.scaleRot = 1;
-
-            if (
-                Math.abs(this.touches[0].x - this.touches[0].prev_x) < 3 &&
-                Math.abs(this.touches[0].y - this.touches[0].prev_y) < 3
-            )
+            if (Math.abs(this.touches[0].x - this.touches[0].prev_x) < 3 &&
+                Math.abs(this.touches[0].y - this.touches[0].prev_y) < 3)
                 this.stopRotation();
         }
     }
-
-    protected onTouchMove(e: ITouchState) {
-        if (e.sys!.touches.length == 1) {
-            let cam = this.planet!.camera;
-
+    onTouchMove(e) {
+        if (e.sys.touches.length == 1) {
+            let cam = this.planet.camera;
             let t = this.touches[0];
-
             t.prev_x = t.x;
             t.prev_y = t.y;
-
-            t.x = e.sys!.touches.item(0)!.pageX - e.sys!.offsetLeft;
-            t.y = e.sys!.touches.item(0)!.pageY - e.sys!.offsetTop;
-
-            if (!t.grabbedPoint) return;
-
+            t.x = e.sys.touches.item(0).pageX - e.sys.offsetLeft;
+            t.y = e.sys.touches.item(0).pageY - e.sys.offsetTop;
+            if (!t.grabbedPoint)
+                return;
             let direction = cam.unproject(t.x, t.y);
             let targetPoint = new Ray(cam.eye, direction).hitSphere(t.grabbedSpheroid);
-
             if (targetPoint) {
                 this._a =
                     Math.acos(t.grabbedPoint.y / t.grabbedSpheroid.radius) -
-                    Math.acos(targetPoint.y / t.grabbedSpheroid.radius);
+                        Math.acos(targetPoint.y / t.grabbedSpheroid.radius);
                 this._vRot = Quat.axisAngleToQuat(cam._u, this._a);
-                this._hRot = Quat.getRotationBetweenVectors(
-                    new Vec3(targetPoint.x, 0.0, targetPoint.z).normal(),
-                    new Vec3(t.grabbedPoint.x, 0.0, t.grabbedPoint.z).normal()
-                );
-
+                this._hRot = Quat.getRotationBetweenVectors(new Vec3(targetPoint.x, 0.0, targetPoint.z).normal(), new Vec3(t.grabbedPoint.x, 0.0, t.grabbedPoint.z).normal());
                 let rot = this._hRot.mul(this._vRot);
-
                 let state = this.positionState[this.currState];
-
                 let lim = rot.mulVec3(cam.eye).normal().dot(Vec3.NORTH);
-
                 if (lim > state.max || lim < state.min) {
                     rot = Quat.yRotation(rot.getYaw());
                 }
-
                 cam.set(rot.mulVec3(cam.eye), Vec3.ZERO, Vec3.NORTH);
                 cam.update();
             }
         }
     }
-
-    protected onMouseLeftButtonClick(e: IMouseState) {
-        this.renderer!.handler.canvas!.classList.add("ogGrabbingPoiner");
-        this.grabbedPoint = this.planet!.getCartesianFromMouseTerrain() || null;
+    onMouseLeftButtonClick(e) {
+        this.renderer.handler.canvas.classList.add("ogGrabbingPoiner");
+        this.grabbedPoint = this.planet.getCartesianFromMouseTerrain() || null;
         this.grabbedDir.copy(e.direction);
         if (this.grabbedPoint) {
             this.grabbedSpheroid.radius = this.grabbedPoint.length();
             this.stopRotation();
         }
     }
-
-    public stopRotation() {
+    stopRotation() {
         this.scaleRot = 0.0;
         this._a = 0.0;
         this._vRot.clear();
         this._hRot.clear();
     }
-
-    protected onMouseLeftButtonUp(e: IMouseState) {
+    onMouseLeftButtonUp(e) {
         this.scaleRot = 1;
-        this.renderer!.handler.canvas!.classList.remove("ogGrabbingPoiner");
-        if (Math.abs(e.x - e.prev_x) < 3 && Math.abs(e.y - e.prev_y) < 3) this.stopRotation();
+        this.renderer.handler.canvas.classList.remove("ogGrabbingPoiner");
+        if (Math.abs(e.x - e.prev_x) < 3 && Math.abs(e.y - e.prev_y) < 3)
+            this.stopRotation();
     }
-
-    protected onMouseLeftButtonDown(e: IMouseState) {
-        let cam = this.planet!.camera;
-
-        if (!this.grabbedPoint || cam.isFlying()) return;
-
-        if (this.renderer!.events.mouseState.moving) {
+    onMouseLeftButtonDown(e) {
+        let cam = this.planet.camera;
+        if (!this.grabbedPoint || cam.isFlying())
+            return;
+        if (this.renderer.events.mouseState.moving) {
             let targetPoint = new Ray(cam.eye, e.direction).hitSphere(this.grabbedSpheroid);
-
             if (targetPoint) {
-
                 this._a = Math.acos(this.grabbedPoint.y / this.grabbedSpheroid.radius) -
                     Math.acos(targetPoint.y / this.grabbedSpheroid.radius);
-
                 let rot = this._vRot = Quat.axisAngleToQuat(cam._u, this._a);
-
                 cam.set(rot.mulVec3(cam.eye), Vec3.ZERO, rot.mulVec3(cam.getUp()));
-
-                this._hRot = Quat.getRotationBetweenVectors(
-                    new Vec3(targetPoint.x, 0.0, targetPoint.z).normal(),
-                    new Vec3(this.grabbedPoint.x, 0.0, this.grabbedPoint.z).normal()
-                );
-
+                this._hRot = Quat.getRotationBetweenVectors(new Vec3(targetPoint.x, 0.0, targetPoint.z).normal(), new Vec3(this.grabbedPoint.x, 0.0, this.grabbedPoint.z).normal());
                 rot = this._hRot;
-
                 cam.set(rot.mulVec3(cam.eye), Vec3.ZERO, rot.mulVec3(cam.getUp()));
                 cam.update();
             }
-        } else {
+        }
+        else {
             this.scaleRot = 0;
         }
     }
-
-    protected onDraw() {
-        let r = this.renderer!;
-        let cam = this.planet!.camera;
-
-        if (r.events.mouseState.leftButtonDown || !this.scaleRot || cam.isFlying()) return;
-
+    onDraw() {
+        let r = this.renderer;
+        let cam = this.planet.camera;
+        if (r.events.mouseState.leftButtonDown || !this.scaleRot || cam.isFlying())
+            return;
         this.scaleRot -= this.inertia;
         if (this.scaleRot <= 0) {
             this.scaleRot = 0;
-        } else {
+        }
+        else {
             this._vRot = Quat.axisAngleToQuat(cam._u, this._a);
-
             let rot = this._vRot.mul(this._hRot);
-
             let lim = rot.mulVec3(cam.eye).normal().dot(Vec3.NORTH);
-
             let state = this.positionState[this.currState];
-
             if (lim > state.max || lim < state.min) {
                 rot = Quat.yRotation(rot.getYaw());
             }
-
             r.controlsBag.scaleRot = this.scaleRot;
             rot = rot
                 .slerp(Quat.IDENTITY, 1 - this.scaleRot * this.scaleRot * this.scaleRot)
@@ -285,7 +195,6 @@ export class EarthNavigation extends Control {
             if (!(rot.x || rot.y || rot.z)) {
                 this.scaleRot = 0;
             }
-
             cam.set(rot.mulVec3(cam.eye), Vec3.ZERO, Vec3.NORTH);
             cam.update();
         }

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

@@ -0,0 +1,22 @@
+import { Control, IControlParams } from './Control';
+import { Layer } from "../layer/Layer";
+import { ToggleButton } from "../ui/ToggleButton";
+import { IMouseState } from "../renderer/RendererEvents";
+interface IGeoImageDragControlParams extends IControlParams {
+}
+export declare class GeoImageDragControl extends Control {
+    protected _cornerIndex: number;
+    protected _catchCorner: boolean;
+    protected _toggleBtn: ToggleButton;
+    constructor(options?: IGeoImageDragControlParams);
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+    _bindLayer(layer: Layer): void;
+    protected _unbindLayer(layer: Layer): void;
+    protected _onLUp(ms: IMouseState): void;
+    protected _onLDown(ms: IMouseState): void;
+    protected _onMouseLeave(): void;
+    protected _onMouseMove(ms: IMouseState): void;
+}
+export {};

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

@@ -1,68 +1,48 @@
-import {BaseGeoImage} from '../layer/BaseGeoImage';
-import {Control, IControlParams} from './Control';
-import {Layer} from "../layer/Layer";
-import {ToggleButton} from "../ui/ToggleButton";
-import {IMouseState} from "../renderer/RendererEvents";
-
+import { BaseGeoImage } from '../layer/BaseGeoImage';
+import { Control } from './Control';
+import { ToggleButton } from "../ui/ToggleButton";
 const ICON_BUTTON_SVG = `<?xml version="1.0" encoding="UTF-8" standalone="no"?> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path d="M16 13l6.964 4.062-2.973.85 2.125 3.681-1.732 1-2.125-3.68-2.223 2.15L16 13zm-2-7h2v2h5a1 1 0 0 1 1 1v4h-2v-3H10v10h4v2H9a1 1 0 0 1-1-1v-5H6v-2h2V9a1 1 0 0 1 1-1h5V6zM4 14v2H2v-2h2zm0-4v2H2v-2h2zm0-4v2H2V6h2zm0-4v2H2V2h2zm4 0v2H6V2h2zm4 0v2h-2V2h2zm4 0v2h-2V2h2z" fill="#000"/></svg>`;
-
-interface IGeoImageDragControlParams extends IControlParams {
-
-}
-
 export class GeoImageDragControl extends Control {
-    protected _cornerIndex: number;
-    protected _catchCorner: boolean;
-    protected _toggleBtn: ToggleButton;
-
-    constructor(options: IGeoImageDragControlParams = {}) {
+    constructor(options = {}) {
         super(options);
-
         this._cornerIndex = -1;
         this._catchCorner = false;
-
         this._toggleBtn = new ToggleButton({
             classList: ["og-map-button", "og-geoimagegrag_button"],
             icon: ICON_BUTTON_SVG
         });
     }
-
-    override oninit() {
-        this._toggleBtn.appendTo(this.renderer!.div!);
-
-        this.planet!.events.on('layeradd', (e: Layer) => {
+    oninit() {
+        this._toggleBtn.appendTo(this.renderer.div);
+        this.planet.events.on('layeradd', (e) => {
             if (this.isActive()) {
                 this._bindLayer(e);
             }
         }, this);
-
-        this._toggleBtn.events.on("change", (isActive: boolean) => {
+        this._toggleBtn.events.on("change", (isActive) => {
             if (isActive) {
                 this.activate();
-            } else {
+            }
+            else {
                 this.deactivate();
             }
         });
     }
-
-    override onactivate() {
+    onactivate() {
         super.onactivate();
-
-        const p = this.planet!;
+        const p = this.planet;
         for (let i = 0; i < p.layers.length; i++) {
             this._bindLayer(p.layers[i]);
         }
     }
-
-    override ondeactivate() {
+    ondeactivate() {
         super.ondeactivate();
-        const p = this.planet!;
+        const p = this.planet;
         for (let i = 0; i < p.layers.length; i++) {
             this._unbindLayer(p.layers[i]);
         }
     }
-
-    _bindLayer(layer: Layer) {
+    _bindLayer(layer) {
         if (layer instanceof BaseGeoImage) {
             layer.events.on('mousemove', this._onMouseMove, this);
             layer.events.on("mouseleave", this._onMouseLeave, this);
@@ -70,8 +50,7 @@ export class GeoImageDragControl extends Control {
             layer.events.on('lup', this._onLUp, this);
         }
     }
-
-    protected _unbindLayer(layer: Layer) {
+    _unbindLayer(layer) {
         if (layer instanceof BaseGeoImage) {
             layer.events.off('mousemove', this._onMouseMove);
             layer.events.off("mouseleave", this._onMouseLeave);
@@ -79,32 +58,29 @@ export class GeoImageDragControl extends Control {
             layer.events.off('lup', this._onLUp);
         }
     }
-
-    protected _onLUp(ms: IMouseState) {
+    _onLUp(ms) {
         this._catchCorner = false;
         ms.renderer.controls.mouseNavigation.activate();
     }
-
-    protected _onLDown(ms: IMouseState) {
+    _onLDown(ms) {
         if (this._cornerIndex !== -1) {
             this._catchCorner = true;
             ms.renderer.controls.mouseNavigation.deactivate();
         }
     }
-
-    protected _onMouseLeave() {
+    _onMouseLeave() {
         document.body.style.cursor = 'auto';
     }
-
-    protected _onMouseMove(ms: IMouseState) {
+    _onMouseMove(ms) {
         let layer = ms.pickingObject;
-        const p = this.planet!;
-        if (this._catchCorner) {// mouse is catching a corner
+        const p = this.planet;
+        if (this._catchCorner) { // mouse is catching a corner
             let corners = layer.getCornersLonLat();
             // corners[this._cornerIndex] = p.getLonLatFromPixelTerrain(ms, true);
             corners[this._cornerIndex] = p.getLonLatFromPixelTerrain(ms);
             layer.setCornersLonLat(corners);
-        } else { // mouse isn't catching
+        }
+        else { // mouse isn't catching
             this._cornerIndex = -1;
             for (let i = 0; i < layer._cornersWgs84.length; i++) {
                 // let ground = p.getLonLatFromPixelTerrain(ms, true);
@@ -116,7 +92,8 @@ export class GeoImageDragControl extends Control {
                     document.body.style.cursor = 'move';
                     break;
                     // mouse is far
-                } else {
+                }
+                else {
                     document.body.style.cursor = 'auto';
                 }
             }

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

@@ -0,0 +1,28 @@
+import { Control, IControlParams } from "./Control";
+interface IKeyboardNavigationParams extends IControlParams {
+    step?: number;
+}
+/**
+ * Planet camera keyboard navigation. Use W,S,A,D and left shift key for fly around a planet.
+ */
+export declare class KeyboardNavigation extends Control {
+    step: number;
+    constructor(options?: IKeyboardNavigationParams);
+    onactivate(): void;
+    ondeactivate(): void;
+    oninit(): void;
+    protected onCameraMoveForward(): void;
+    protected onCameraMoveBackward(): void;
+    protected onCameraStrifeLeft(): void;
+    protected onCameraStrifeRight(): void;
+    protected onCameraLookUp(): void;
+    protected onCameraLookDown(): void;
+    protected onCameraLookLeft(): void;
+    protected onCameraLookRight(): void;
+    protected onCameraTurnLeft(): void;
+    protected onCameraTurnRight(): void;
+    protected onCameraRollNorth(): void;
+    protected onCameraRollLeft(): void;
+    protected onCameraRollRight(): void;
+}
+export {};