@openglobus/og 0.18.0 → 0.18.2

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

@@ -1,84 +1,59 @@
-import {Control, IControlParams} from "./Control";
-import {htmlColorToRgb} from "../utils/shared";
-import {Program} from '../webgl/Program';
-
-interface ISimpleSkyBackgroundParams extends IControlParams {
-
-}
-
+import { Control } from "./Control";
+import { htmlColorToRgb } from "../utils/shared";
+import { Program } from '../webgl/Program';
 export class SimpleSkyBackground extends Control {
-    protected _colorOne: Float32Array;
-    protected _colorTwo: Float32Array;
-
-    constructor(options: ISimpleSkyBackgroundParams = {}) {
+    constructor(options = {}) {
         super({
             name: "SimpleSkyBackground",
             ...options
         });
-
         this._colorOne = new Float32Array([1.0, 1.0, 1.0]);
         this._colorTwo = new Float32Array([0.0, 153.0 / 255.0, 221.0 / 255.0]);
     }
-
-    public set colorOne(htmlColor: string) {
+    set colorOne(htmlColor) {
         let rgb = htmlColorToRgb(htmlColor);
         this._colorOne[0] = rgb.x;
         this._colorOne[1] = rgb.y;
         this._colorOne[2] = rgb.z;
     }
-
-    public set colorTwo(htmlColor: string) {
+    set colorTwo(htmlColor) {
         let rgb = htmlColorToRgb(htmlColor);
         this._colorTwo[0] = rgb.x;
         this._colorTwo[1] = rgb.y;
         this._colorTwo[2] = rgb.z;
     }
-
-    public override oninit() {
-        this.renderer!.handler.addProgram(simpleSkyBackgroundShader());
+    oninit() {
+        this.renderer.handler.addProgram(simpleSkyBackgroundShader());
         this.activate();
     }
-
-    public override onactivate() {
+    onactivate() {
         super.onactivate();
-        this.planet!.events.on("draw", this._drawBackground, this);
+        this.planet.events.on("draw", this._drawBackground, this);
     }
-
-    public override ondeactivate() {
+    ondeactivate() {
         super.ondeactivate();
-        this.planet!.events.off("draw", this._drawBackground);
+        this.planet.events.off("draw", this._drawBackground);
     }
-
-    protected _drawBackground() {
-        let h = this.renderer!.handler;
-        let sh = h.programs.simpleSkyBackground,
-            p = sh._program,
-            shu = p.uniforms,
-            gl = h.gl!;
-        let cam = this.planet!.camera;
-
+    _drawBackground() {
+        let h = this.renderer.handler;
+        let sh = h.programs.simpleSkyBackground, p = sh._program, shu = p.uniforms, gl = h.gl;
+        let cam = this.planet.camera;
         gl.disable(gl.DEPTH_TEST);
-
         sh.activate();
-        gl.bindBuffer(gl.ARRAY_BUFFER, this.renderer!.screenFramePositionBuffer!);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this.renderer.screenFramePositionBuffer);
         gl.vertexAttribPointer(p.attributes.corners, 2, gl.FLOAT, false, 0, 0);
-
         gl.uniform3fv(shu.camPos, [cam.eye.x, cam.eye.y, cam.eye.z]);
         gl.uniform2fv(shu.iResolution, [h.getWidth(), h.getHeight()]);
         gl.uniform1f(shu.fov, cam.getViewAngle());
-        gl.uniform1f(shu.earthRadius, this.planet!.ellipsoid.getPolarSize() + 1);
+        gl.uniform1f(shu.earthRadius, this.planet.ellipsoid.getPolarSize() + 1);
         gl.uniform3fv(shu.colorOne, this._colorOne);
         gl.uniform3fv(shu.colorTwo, this._colorTwo);
-
         gl.uniformMatrix4fv(shu.viewMatrix, false, cam.getViewMatrix());
-
         gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-
         gl.enable(gl.DEPTH_TEST);
     }
 }
-
-function simpleSkyBackgroundShader(): Program {
+function simpleSkyBackgroundShader() {
     return new Program("simpleSkyBackground", {
         uniforms: {
             iResolution: "vec2", fov: "float",
@@ -90,8 +65,7 @@ function simpleSkyBackgroundShader(): Program {
         }, attributes: {
             corners: "vec3"
         },
-        vertexShader:
-            `attribute vec2 corners;
+        vertexShader: `attribute vec2 corners;
                         
             varying vec2 tc;
             
@@ -99,8 +73,7 @@ function simpleSkyBackgroundShader(): Program {
                 gl_Position = vec4(corners, 0.0, 1.0);
                 tc = corners * 0.5 + 0.5;
             }`,
-        fragmentShader:
-            `precision highp float;
+        fragmentShader: `precision highp float;
             
             #define MAX 10e10
             #define PI 3.14159265359

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

@@ -0,0 +1,33 @@
+import { Control, IControlParams } from "./Control";
+import { Clock } from "../Clock";
+import { LightSource } from "../light/LightSource";
+interface ISunParams extends IControlParams {
+    activationHeight?: number;
+    offsetVertical?: number;
+    offsetHorizontal?: number;
+    stopped?: boolean;
+}
+/**
+ * Real Sun geocentric position control that place the Sun on the right place by the Earth.
+ */
+export declare class Sun extends Control {
+    activationHeight: number;
+    offsetVertical: number;
+    offsetHorizontal: number;
+    sunlight: LightSource;
+    protected _currDate: number;
+    protected _prevDate: number;
+    protected _clockPtr: Clock | null;
+    protected _lightOn: boolean;
+    protected _stopped: boolean;
+    protected _f: number;
+    protected _k: number;
+    constructor(options?: ISunParams);
+    oninit(): void;
+    stop(): void;
+    start(): void;
+    onactivate(): void;
+    bindClock(clock: Clock): void;
+    protected _draw(): void;
+}
+export {};

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

@@ -1,159 +1,107 @@
-import {Control, IControlParams} from "./Control";
-import {Clock} from "../Clock";
-import {getSunPosition} from "../astro/earth";
-import {LightSource} from "../light/LightSource";
-import {Quat} from "../math/Quat";
-import {Vec3} from "../math/Vec3";
-
-interface ISunParams extends IControlParams {
-    activationHeight?: number;
-    offsetVertical?: number;
-    offsetHorizontal?: number;
-    stopped?: boolean;
-}
-
+import { Control } from "./Control";
+import { getSunPosition } from "../astro/earth";
+import { LightSource } from "../light/LightSource";
+import { Quat } from "../math/Quat";
+import { Vec3 } from "../math/Vec3";
 /**
  * Real Sun geocentric position control that place the Sun on the right place by the Earth.
  */
 export class Sun extends Control {
-    public activationHeight: number;
-    public offsetVertical: number;
-    public offsetHorizontal: number;
-    public sunlight: LightSource;
-
-    protected _currDate: number;
-    protected _prevDate: number;
-    protected _clockPtr: Clock | null;
-    protected _lightOn: boolean;
-    protected _stopped: boolean;
-    protected _f: number;
-    protected _k: number;
-
-    constructor(options: ISunParams = {}) {
-        super({autoActivate: true, ...options});
-
+    constructor(options = {}) {
+        super({ autoActivate: true, ...options });
         this._name = "sun";
-
         this.activationHeight = options.activationHeight || 12079000.0;
-
         this.offsetVertical = options.offsetVertical || -5000000;
-
         this.offsetHorizontal = options.offsetHorizontal || 5000000;
-
         this.sunlight = new LightSource("Sun", {
             ambient: new Vec3(0.15, 0.15, 0.25),
             diffuse: new Vec3(0.9, 0.9, 0.8),
             specular: new Vec3(0.1, 0.1, 0.06),
             shininess: 110
         });
-
         /**
          * Current frame handler clock date and time.
          * @private
          * @type {Number}
          */
         this._currDate = 0;
-
         /**
          * Previous frame handler clock date and time.
          * @private
          * @type {Number}
          */
         this._prevDate = 0;
-
         this._clockPtr = null;
-
         this._lightOn = false;
-
         this._f = 0;
         this._k = 0;
-
         this._stopped = options.stopped || false;
     }
-
-    public override oninit() {
-        this.planet!.lightEnabled = true;
-
+    oninit() {
+        this.planet.lightEnabled = true;
         // sunlight initialization
-        this.sunlight.addTo(this.planet!);
-
-        this.renderer!.events.on("draw", this._draw, this);
-
+        this.sunlight.addTo(this.planet);
+        this.renderer.events.on("draw", this._draw, this);
         if (!this._clockPtr) {
-            this._clockPtr = this.renderer!.handler.defaultClock;
+            this._clockPtr = this.renderer.handler.defaultClock;
         }
     }
-
-    public stop() {
+    stop() {
         this._stopped = true;
         this.deactivate();
     }
-
-    public start() {
+    start() {
         this._stopped = false;
         this.activate();
     }
-
-    public override onactivate() {
+    onactivate() {
         super.onactivate();
         this._stopped = false;
     }
-
-    public bindClock(clock: Clock) {
+    bindClock(clock) {
         this._clockPtr = clock;
     }
-
-    protected _draw() {
-        if (!this._clockPtr) return;
+    _draw() {
+        if (!this._clockPtr)
+            return;
         this._currDate = this._clockPtr.currentDate;
         if (!this._stopped) {
-            let cam = this.planet!.camera;
+            let cam = this.planet.camera;
             if (cam.getHeight() < this.activationHeight || !this._active) {
                 this._lightOn = true;
                 this._f = 1;
-                let n = cam.eye.normal(),
-                    u = cam.getForward();
-
+                let n = cam.eye.normal(), u = cam.getForward();
                 u.scale(Math.sign(cam._u.dot(n))); // up
-
                 if (cam.slope > 0.99) {
                     u = cam._u;
                 }
-
                 let tu = Vec3.proj_b_to_plane(u, n, u).normalize().scale(this.offsetVertical);
                 let tr = Vec3.proj_b_to_plane(cam._r, n, cam._r)
                     .normalize()
                     .scale(this.offsetHorizontal); // right
-
                 let d = tu.add(tr);
                 let pos = cam.eye.add(d);
-
                 if (this._k > 0) {
                     this._k -= 0.01;
-                    let rot = Quat.getRotationBetweenVectors(
-                        this.sunlight._position.normal(),
-                        pos.normal()
-                    );
+                    let rot = Quat.getRotationBetweenVectors(this.sunlight._position.normal(), pos.normal());
                     let r = rot.slerp(Quat.IDENTITY, this._k).normalize();
                     this.sunlight.setPosition3v(r.mulVec3(this.sunlight._position));
-                } else {
+                }
+                else {
                     this.sunlight.setPosition3v(pos);
                 }
-            } else {
+            }
+            else {
                 this._k = 1;
                 if (this._f > 0) {
                     this._f -= 0.01;
-                    let rot = Quat.getRotationBetweenVectors(
-                        this.sunlight._position.normal(),
-                        getSunPosition(this._currDate).normal()
-                    );
+                    let rot = Quat.getRotationBetweenVectors(this.sunlight._position.normal(), getSunPosition(this._currDate).normal());
                     let r = rot.slerp(Quat.IDENTITY, this._f).normalize();
                     this.sunlight.setPosition3v(r.mulVec3(this.sunlight._position));
-                } else {
-                    if (
-                        (Math.abs(this._currDate - this._prevDate) > 0.00034 && this._active) ||
-                        this._lightOn
-                    ) {
+                }
+                else {
+                    if ((Math.abs(this._currDate - this._prevDate) > 0.00034 && this._active) ||
+                        this._lightOn) {
                         this._lightOn = false;
                         this._prevDate = this._currDate;
                         this.sunlight.setPosition3v(getSunPosition(this._currDate));
@@ -161,8 +109,9 @@ export class Sun extends Control {
                     }
                 }
             }
-        } else {
+        }
+        else {
             this.sunlight.setPosition3v(getSunPosition(this._currDate));
         }
     }
-}
+}

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

@@ -0,0 +1,14 @@
+import { Control, IControlParams } from "./Control";
+interface IToggleWireframe extends IControlParams {
+    isActive?: boolean;
+}
+/**
+ * Planet GL draw mode(TRIANGLE_STRIP/LINE_STRING) changer.
+ */
+export declare class ToggleWireframe extends Control {
+    protected _isActive: boolean;
+    constructor(options?: IToggleWireframe);
+    oninit(): void;
+    toogleWireframe: () => void;
+}
+export {};

package/lib/js/control/ToggleWireframe.js

@@ -0,0 +1,28 @@
+import { input } from "../input/input";
+import { Control } from "./Control";
+/**
+ * Planet GL draw mode(TRIANGLE_STRIP/LINE_STRING) changer.
+ */
+export class ToggleWireframe extends Control {
+    constructor(options = {}) {
+        super(options);
+        this._isActive = false;
+        this.toogleWireframe = () => {
+            if (this.renderer && this.renderer.handler.gl) {
+                if (this.planet.drawMode === this.renderer.handler.gl.LINE_STRIP) {
+                    this.planet.setDrawMode(this.renderer.handler.gl.TRIANGLE_STRIP);
+                }
+                else {
+                    this.planet.setDrawMode(this.renderer.handler.gl.LINE_STRIP);
+                }
+            }
+        };
+        this._isActive = options.isActive || false;
+    }
+    oninit() {
+        this.renderer.events.on("charkeypress", input.KEY_X, this.toogleWireframe, this);
+        if (this._isActive) {
+            this.planet.setDrawMode(this.renderer.handler.gl.LINE_STRIP);
+        }
+    }
+}

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

@@ -0,0 +1,52 @@
+import { Control, IControlParams } from "./Control";
+import { Key } from "../Lock";
+import { Quat } from "../math/Quat";
+import { Sphere } from "../bv/Sphere";
+import { Vec2 } from "../math/Vec2";
+import { Vec3 } from "../math/Vec3";
+import { ITouchState } from "../renderer/RendererEvents";
+interface ITouchNavigationParams extends IControlParams {
+}
+declare class TouchExt {
+    x: number;
+    y: number;
+    prev_x: number;
+    prev_y: number;
+    grabbedPoint: Vec3 | null;
+    grabbedSpheroid: Sphere;
+    protected _vec: Vec2;
+    protected _vecPrev: Vec2;
+    constructor();
+    get dY(): number;
+    get dX(): number;
+    get vec(): Vec2;
+    get vecPrev(): Vec2;
+}
+/**
+ * Touch pad planet camera dragging control.
+ */
+export declare class TouchNavigation extends Control {
+    grabbedPoint: Vec3;
+    inertia: number;
+    protected grabbedSpheroid: Sphere;
+    protected qRot: Quat;
+    protected scaleRot: number;
+    protected rot: number;
+    protected _eye0: Vec3;
+    protected pointOnEarth: Vec3 | null;
+    protected earthUp: Vec3 | null;
+    protected touches: TouchExt[];
+    protected _keyLock: Key;
+    protected _touching: boolean;
+    constructor(options?: ITouchNavigationParams);
+    oninit(): void;
+    protected onTouchStart(e: ITouchState): void;
+    protected _startTouchOne(e: ITouchState): void;
+    stopRotation(): void;
+    protected onDoubleTouch(e: ITouchState): void;
+    protected onTouchEnd(e: ITouchState): void;
+    protected onTouchCancel(e: ITouchState): void;
+    protected onTouchMove(e: ITouchState): void;
+    protected onDraw(): void;
+}
+export {};