@openglobus/og 0.17.1 → 0.18.0

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

@@ -1,17 +1,16 @@
-"use strict";
-
-import { htmlColorToRgb } from "../utils/shared.js";
-import { Program } from '../webgl/Program.js';
-import { Control } from "./Control.js";
-
-/**
- * Frame per second(FPS) display control.
- * @class
- * @extends {Control}
- * @param {Object} [options] - Control options.
- */
-class SimpleSkyBackground extends Control {
-    constructor(options) {
+import {Control, IControlParams} from "./Control";
+import {htmlColorToRgb} from "../utils/shared";
+import {Program} from '../webgl/Program';
+
+interface ISimpleSkyBackgroundParams extends IControlParams {
+
+}
+
+export class SimpleSkyBackground extends Control {
+    protected _colorOne: Float32Array;
+    protected _colorTwo: Float32Array;
+
+    constructor(options: ISimpleSkyBackgroundParams = {}) {
         super({
             name: "SimpleSkyBackground",
             ...options
@@ -21,54 +20,57 @@ class SimpleSkyBackground extends Control {
         this._colorTwo = new Float32Array([0.0, 153.0 / 255.0, 221.0 / 255.0]);
     }
 
-    set colorOne(htmlColor) {
+    public set colorOne(htmlColor: string) {
         let rgb = htmlColorToRgb(htmlColor);
         this._colorOne[0] = rgb.x;
         this._colorOne[1] = rgb.y;
         this._colorOne[2] = rgb.z;
     }
 
-    set colorTwo(htmlColor) {
+    public set colorTwo(htmlColor: string) {
         let rgb = htmlColorToRgb(htmlColor);
         this._colorTwo[0] = rgb.x;
         this._colorTwo[1] = rgb.y;
         this._colorTwo[2] = rgb.z;
     }
 
-    oninit() {
-        this.renderer.handler.addProgram(simpleSkyBackgroundShader());
+    public override oninit() {
+        this.renderer!.handler.addProgram(simpleSkyBackgroundShader());
         this.activate();
     }
 
-    onactivate() {
+    public override onactivate() {
         super.onactivate();
-        this.planet.events.on("draw", this._drawBackground, this);
+        this.planet!.events.on("draw", this._drawBackground, this);
     }
 
-    ondeactivate() {
+    public override ondeactivate() {
         super.ondeactivate();
-        this.planet.events.off("draw", this._drawBackground);
+        this.planet!.events.off("draw", this._drawBackground);
     }
 
-    _drawBackground() {
-        let h = this.renderer.handler;
-        let sh = h.programs.simpleSkyBackground, p = sh._program, shu = p.uniforms, gl = h.gl;
-        let cam = this.renderer.activeCamera;
+    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;
 
         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._viewMatrix._m);
+        gl.uniformMatrix4fv(shu.viewMatrix, false, cam.getViewMatrix());
 
         gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
 
@@ -76,11 +78,7 @@ class SimpleSkyBackground extends Control {
     }
 }
 
-export function simpleSkyBackground(options) {
-    return new SimpleSkyBackground(options);
-}
-
-function simpleSkyBackgroundShader() {
+function simpleSkyBackgroundShader(): Program {
     return new Program("simpleSkyBackground", {
         uniforms: {
             iResolution: "vec2", fov: "float",
@@ -91,7 +89,8 @@ function simpleSkyBackgroundShader() {
             colorTwo: "vec3"
         }, attributes: {
             corners: "vec3"
-        }, vertexShader:
+        },
+        vertexShader:
             `attribute vec2 corners;
                         
             varying vec2 tc;
@@ -99,7 +98,8 @@ function simpleSkyBackgroundShader() {
             void main(void) {
                 gl_Position = vec4(corners, 0.0, 1.0);
                 tc = corners * 0.5 + 0.5;
-            }`, fragmentShader:
+            }`,
+        fragmentShader:
             `precision highp float;
             
             #define MAX 10e10
@@ -202,5 +202,3 @@ function simpleSkyBackgroundShader() {
             }`
     });
 }
-
-export { SimpleSkyBackground };

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

@@ -1,51 +1,51 @@
-"use strict";
-
-import { getSunPosition } from "../astro/earth.js";
-import { LightSource } from "../light/LightSource.js";
-import { Quat } from "../math/Quat.js";
-import { Vec3 } from "../math/Vec3.js";
-import { Control } from "./Control.js";
+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;
+}
 
 /**
  * Real Sun geocentric position control that place the Sun on the right place by the Earth.
- * @class
- * @extends {Control}
- * @param {Object} [options] - Control options.
  */
-class Sun extends Control {
-    constructor(options) {
-        super({ autoActivate: true, ...options });
+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});
 
         this._name = "sun";
 
-        options = options || {};
-
-        /**
-         * Earth planet node.
-         * @public
-         * @type {Planet}
-         */
-        this.planet = null;
-
-        /**
-         * Sunlight position placed in the camera eye.
-         * @private
-         * @type {boolean}
-         */
-        // this._isCameraSunlight = false;
-
         this.activationHeight = options.activationHeight || 12079000.0;
 
         this.offsetVertical = options.offsetVertical || -5000000;
 
         this.offsetHorizontal = options.offsetHorizontal || 5000000;
 
-        /**
-         * Light source.
-         * @public
-         * @type {LightSource}
-         */
-        this.sunlight = null;
+        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.
@@ -65,55 +65,53 @@ class Sun extends Control {
 
         this._lightOn = false;
 
+        this._f = 0;
+        this._k = 0;
+
         this._stopped = options.stopped || false;
     }
 
-    oninit() {
-        this.planet.lightEnabled = true;
+    public override oninit() {
+        this.planet!.lightEnabled = true;
 
         // sunlight initialization
-        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
-        });
-        this.sunlight.addTo(this.planet);
+        this.sunlight.addTo(this.planet!);
 
-        this.renderer.events.on("draw", this._draw, this);
+        this.renderer!.events.on("draw", this._draw, this);
 
         if (!this._clockPtr) {
-            this._clockPtr = this.renderer.handler.defaultClock;
+            this._clockPtr = this.renderer!.handler.defaultClock;
         }
     }
 
-    stop() {
+    public stop() {
         this._stopped = true;
         this.deactivate();
     }
 
-    start() {
+    public start() {
         this._stopped = false;
         this.activate();
     }
 
-    onactivate() {
+    public override onactivate() {
         super.onactivate();
         this._stopped = false;
     }
 
-    bindClock(clock) {
+    public bindClock(clock: Clock) {
         this._clockPtr = clock;
     }
 
-    _draw() {
+    protected _draw() {
+        if (!this._clockPtr) return;
         this._currDate = this._clockPtr.currentDate;
         if (!this._stopped) {
-            var cam = this.renderer.activeCamera;
+            let cam = this.planet!.camera;
             if (cam.getHeight() < this.activationHeight || !this._active) {
                 this._lightOn = true;
                 this._f = 1;
-                var n = cam.eye.normal(),
+                let n = cam.eye.normal(),
                     u = cam.getForward();
 
                 u.scale(Math.sign(cam._u.dot(n))); // up
@@ -122,13 +120,13 @@ class Sun extends Control {
                     u = cam._u;
                 }
 
-                var tu = Vec3.proj_b_to_plane(u, n, u).normalize().scale(this.offsetVertical);
-                var tr = Vec3.proj_b_to_plane(cam._r, n, cam._r)
+                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
 
-                var d = tu.add(tr);
-                var pos = cam.eye.add(d);
+                let d = tu.add(tr);
+                let pos = cam.eye.add(d);
 
                 if (this._k > 0) {
                     this._k -= 0.01;
@@ -167,10 +165,4 @@ class Sun extends Control {
             this.sunlight.setPosition3v(getSunPosition(this._currDate));
         }
     }
-}
-
-export function sun(options) {
-    return new Sun(options);
-}
-
-export { Sun };
+}

package/src/control/ToggleWireframe.ts

@@ -0,0 +1,35 @@
+import {input} from "../input/input";
+import {Control, IControlParams} from "./Control";
+
+interface IToggleWireframe extends IControlParams {
+    isActive?: boolean;
+}
+
+/**
+ * Planet GL draw mode(TRIANGLE_STRIP/LINE_STRING) changer.
+ */
+export class ToggleWireframe extends Control {
+    protected _isActive = false;
+
+    constructor(options: IToggleWireframe = {}) {
+        super(options);
+        this._isActive = options.isActive || false;
+    }
+
+    public override oninit() {
+        this.renderer!.events.on("charkeypress", input.KEY_X, this.toogleWireframe, this);
+        if (this._isActive) {
+            this.planet!.setDrawMode(this.renderer!.handler.gl!.LINE_STRIP);
+        }
+    }
+
+    public 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);
+            }
+        }
+    }
+}