@openglobus/og 0.17.2 → 0.18.1

package/lib/js/control/ScaleControl.js

@@ -0,0 +1,91 @@
+import { binarySearch, parseHTML } from "../utils/shared";
+import { Control } from "./Control";
+import { RADIANS } from "../math";
+import { Vec3 } from "../math/Vec3";
+const scale = [
+    1, 2, 3, 5, 10, 20, 30, 50, 100, 200, 300, 500, 1e3, 2e3, 3e3, 5e3, 10e3, 20e3, 30e3, 50e3,
+    100e3, 200e3, 300e3, 500e3, 1000e3, 2000e3, 3000e3, 5000e3, 10000e3
+];
+const TEMPLATE = `<div class="og-scale-container">
+      <div class="og-scale-label"></div>
+      <div class="og-scale-ruler"></div>
+    </div>`;
+/**
+ * Planet zoom buttons control.
+ */
+export class ScaleControl extends Control {
+    constructor(options = {}) {
+        if (!options.name || options.name === "") {
+            options.name = "scaleControl";
+        }
+        super(options);
+        this._template = TEMPLATE;
+        this._minWidth = 100;
+        this._maxWidth = 150;
+        this._isCenter = options.isCenter != undefined ? options.isCenter : true;
+        this._mPx = 0;
+        this.currWidth = 0;
+        this._metersInMinSize = 0;
+        this.el = null;
+        this._scaleLabelEl = null;
+    }
+    _renderTemplate() {
+        return parseHTML(this._template)[0];
+    }
+    oninit() {
+        this.el = this._renderTemplate();
+        this._scaleLabelEl = this.el.querySelector(".og-scale-label");
+        this.renderer.div.appendChild(this.el);
+        if (this._isCenter) {
+            this.planet.camera.events.on("moveend", () => {
+                this._drawScreen(this.planet.renderer.handler.getCenter());
+            });
+            !this.planet.terrain.isEmpty && this.planet.terrain.events.on("loadend", () => {
+                this._drawScreen(this.planet.renderer.handler.getCenter());
+            });
+        }
+        else {
+            this.renderer.events.on("mousemove", (e) => {
+                if (!e.leftButtonHold && !e.rightButtonHold) {
+                    this._drawScreen(e.pos);
+                }
+            });
+            this.planet.camera.events.on("moveend", () => {
+                let ms = this.renderer.events.mouseState;
+                if (!ms.leftButtonHold && !ms.rightButtonHold) {
+                    this._drawScreen(ms.pos);
+                }
+            });
+        }
+    }
+    _drawScreen(px) {
+        let cam = this.planet.camera;
+        let s0 = px;
+        let dist = this.planet.getDistanceFromPixel(s0) || 0;
+        if (dist === 0) {
+            s0 = cam.project(Vec3.ZERO);
+            dist = this.planet.getDistanceFromPixel(s0) || 0;
+        }
+        let p0 = cam.getForward().scaleTo(dist).addA(cam.eye);
+        let tempSize = dist * Math.tan(cam.viewAngle * RADIANS);
+        let p1 = p0.add(cam.getRight().scaleTo(tempSize));
+        let s1 = cam.project(p1);
+        this._mPx = tempSize / s1.distance(s0);
+        let metersInMinSize = this._mPx * this._minWidth;
+        let index = binarySearch(scale, metersInMinSize, (a, b) => a - b);
+        if (index < 0) {
+            index = ~index;
+        }
+        let minMeters = scale[index], maxMeters = scale[index + 1];
+        let t = (minMeters - metersInMinSize) / (maxMeters - minMeters);
+        this.currWidth = this._minWidth + t * (this._maxWidth - this._minWidth);
+        if (minMeters > 1000) {
+            this._scaleLabelEl.innerText = `${minMeters / 1000} km`;
+        }
+        else {
+            this._scaleLabelEl.innerText = `${minMeters} m`;
+        }
+        this._metersInMinSize = metersInMinSize;
+        this.el.style.width = this.currWidth + "px";
+    }
+}

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

@@ -0,0 +1,12 @@
+import { EntityCollection } from "../entity/EntityCollection";
+import { Control, IControlParams } from "./Control";
+/**
+ * Frame per second(FPS) display control.
+ */
+export declare class SegmentBoundVisualization extends Control {
+    protected _boundingSphereCollection: EntityCollection;
+    constructor(options: IControlParams);
+    oninit(): void;
+    protected _predraw(): void;
+    protected _draw(): void;
+}

package/lib/js/control/SegmentBoundVisualization.js

@@ -0,0 +1,37 @@
+import { Entity } from "../entity/Entity";
+import { EntityCollection } from "../entity/EntityCollection";
+import { Control } from "./Control";
+/**
+ * Frame per second(FPS) display control.
+ */
+export class SegmentBoundVisualization extends Control {
+    constructor(options) {
+        super(options);
+        this._boundingSphereCollection = new EntityCollection();
+    }
+    oninit() {
+        this.planet.addEntityCollection(this._boundingSphereCollection);
+        this.renderer.events.on("draw", this._predraw, this);
+        this.planet.events.on("draw", this._draw, this);
+    }
+    _predraw() {
+        this._boundingSphereCollection.clear();
+    }
+    _draw() {
+        const planet = this.planet;
+        for (let i = 0; i < planet._renderedNodes.length; i++) {
+            let si = planet._renderedNodes[i].segment;
+            if (!si._sphereEntity) {
+                si._sphereEntity = new Entity({
+                    billboard: {
+                    //todo: replace with sphere geoObject
+                    }
+                });
+            }
+            //@todo: geoObject
+            //si._sphereEntity.shape.setScale(si.bsphere.radius / 2);
+            //si._sphereEntity.shape.setPosition3v(si.bsphere.center);
+            this._boundingSphereCollection.add(si._sphereEntity);
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Control, IControlParams } from "./Control";
+/**
+ * Frame per second(FPS) display control.
+ */
+export declare class ShowFps extends Control {
+    constructor(options: IControlParams);
+    oninit(): void;
+    protected _draw(): void;
+}

package/lib/js/control/ShowFps.js

@@ -0,0 +1,20 @@
+import { print2d } from "../utils/shared";
+import { Control } from "./Control";
+/**
+ * Frame per second(FPS) display control.
+ */
+export class ShowFps extends Control {
+    constructor(options) {
+        super(options);
+    }
+    oninit() {
+        let d = document.createElement("div");
+        d.className = "defaultText ";
+        d.id = "ogShowFpsControl";
+        document.body.appendChild(d);
+        this.renderer.events.on("draw", this._draw, this);
+    }
+    _draw() {
+        print2d("ogShowFpsControl", (1000.0 / this.renderer.handler.deltaTime).toFixed(1), this.renderer.handler.canvas.clientWidth - 60, 0);
+    }
+}

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

@@ -0,0 +1,25 @@
+import { Control, IControlParams } from "./Control";
+interface ISimpleNavigationParams extends IControlParams {
+    speed?: number;
+}
+/**
+ * Simple keyboard camera navigation with W,S,A,D and shift keys to fly around the scene.
+ */
+export declare class SimpleNavigation extends Control {
+    speed: number;
+    constructor(options?: ISimpleNavigationParams);
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+    protected onCameraMoveForward(): void;
+    protected onCameraMoveBackward(): void;
+    protected onCameraStrifeLeft(): void;
+    protected onCameraStrifeRight(): void;
+    protected onCameraLookUp(): void;
+    protected onCameraLookDown(): void;
+    protected onCameraTurnLeft(): void;
+    protected onCameraTurnRight(): void;
+    protected onCameraRollLeft(): void;
+    protected onCameraRollRight(): void;
+}
+export {};

package/lib/js/control/SimpleNavigation.js

@@ -0,0 +1,96 @@
+import { Control } from "./Control";
+import { input } from "../input/input";
+/**
+ * Simple keyboard camera navigation with W,S,A,D and shift keys to fly around the scene.
+ */
+export class SimpleNavigation extends Control {
+    constructor(options = {}) {
+        super({
+            name: "SimpleNavigation",
+            autoActivate: true, ...options
+        });
+        this.speed = options.speed || 1.0;
+    }
+    oninit() {
+    }
+    onactivate() {
+        super.onactivate();
+        let r = this.renderer;
+        r.events.on("keypress", input.KEY_W, this.onCameraMoveForward, this);
+        r.events.on("keypress", input.KEY_S, this.onCameraMoveBackward, this);
+        r.events.on("keypress", input.KEY_A, this.onCameraStrifeLeft, this);
+        r.events.on("keypress", input.KEY_D, this.onCameraStrifeRight, this);
+        r.events.on("keypress", input.KEY_UP, this.onCameraLookUp, this);
+        r.events.on("keypress", input.KEY_DOWN, this.onCameraLookDown, this);
+        r.events.on("keypress", input.KEY_LEFT, this.onCameraTurnLeft, this);
+        r.events.on("keypress", input.KEY_RIGHT, this.onCameraTurnRight, this);
+        r.events.on("keypress", input.KEY_Q, this.onCameraRollLeft, this);
+        r.events.on("keypress", input.KEY_E, this.onCameraRollRight, this);
+    }
+    ondeactivate() {
+        super.ondeactivate();
+        let r = this.renderer;
+        r.events.off("keypress", input.KEY_W, this.onCameraMoveForward);
+        r.events.off("keypress", input.KEY_S, this.onCameraMoveBackward);
+        r.events.off("keypress", input.KEY_A, this.onCameraStrifeLeft);
+        r.events.off("keypress", input.KEY_D, this.onCameraStrifeRight);
+        r.events.off("keypress", input.KEY_UP, this.onCameraLookUp);
+        r.events.off("keypress", input.KEY_DOWN, this.onCameraLookDown);
+        r.events.off("keypress", input.KEY_LEFT, this.onCameraTurnLeft);
+        r.events.off("keypress", input.KEY_RIGHT, this.onCameraTurnRight);
+        r.events.off("keypress", input.KEY_Q, this.onCameraRollLeft);
+        r.events.off("keypress", input.KEY_E, this.onCameraRollRight);
+    }
+    onCameraMoveForward() {
+        if (this._active) {
+            let cam = this.renderer.activeCamera;
+            cam.slide(0, 0, -this.speed);
+            cam.update();
+        }
+    }
+    onCameraMoveBackward() {
+        let cam = this.renderer.activeCamera;
+        cam.slide(0, 0, this.speed);
+        cam.update();
+    }
+    onCameraStrifeLeft() {
+        let cam = this.renderer.activeCamera;
+        cam.slide(-this.speed, 0, 0);
+        cam.update();
+    }
+    onCameraStrifeRight() {
+        let cam = this.renderer.activeCamera;
+        cam.slide(this.speed, 0, 0);
+        cam.update();
+    }
+    onCameraLookUp() {
+        let cam = this.renderer.activeCamera;
+        cam.pitch(0.5);
+        cam.update();
+    }
+    onCameraLookDown() {
+        let cam = this.renderer.activeCamera;
+        cam.pitch(-0.5);
+        cam.update();
+    }
+    onCameraTurnLeft() {
+        let cam = this.renderer.activeCamera;
+        cam.yaw(0.5);
+        cam.update();
+    }
+    onCameraTurnRight() {
+        let cam = this.renderer.activeCamera;
+        cam.yaw(-0.5);
+        cam.update();
+    }
+    onCameraRollLeft() {
+        let cam = this.renderer.activeCamera;
+        cam.roll(-0.5);
+        cam.update();
+    }
+    onCameraRollRight() {
+        let cam = this.renderer.activeCamera;
+        cam.roll(0.5);
+        cam.update();
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Control, IControlParams } from "./Control";
+interface ISimpleSkyBackgroundParams extends IControlParams {
+}
+export declare class SimpleSkyBackground extends Control {
+    protected _colorOne: Float32Array;
+    protected _colorTwo: Float32Array;
+    constructor(options?: ISimpleSkyBackgroundParams);
+    set colorOne(htmlColor: string);
+    set colorTwo(htmlColor: string);
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+    protected _drawBackground(): void;
+}
+export {};

package/lib/js/control/SimpleSkyBackground.js

@@ -0,0 +1,177 @@
+import { Control } from "./Control";
+import { htmlColorToRgb } from "../utils/shared";
+import { Program } from '../webgl/Program';
+export class SimpleSkyBackground extends Control {
+    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]);
+    }
+    set colorOne(htmlColor) {
+        let rgb = htmlColorToRgb(htmlColor);
+        this._colorOne[0] = rgb.x;
+        this._colorOne[1] = rgb.y;
+        this._colorOne[2] = rgb.z;
+    }
+    set colorTwo(htmlColor) {
+        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());
+        this.activate();
+    }
+    onactivate() {
+        super.onactivate();
+        this.planet.events.on("draw", this._drawBackground, this);
+    }
+    ondeactivate() {
+        super.ondeactivate();
+        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.planet.camera;
+        gl.disable(gl.DEPTH_TEST);
+        sh.activate();
+        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.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() {
+    return new Program("simpleSkyBackground", {
+        uniforms: {
+            iResolution: "vec2", fov: "float",
+            camPos: "vec3",
+            earthRadius: "float",
+            viewMatrix: "mat4",
+            colorOne: "vec3",
+            colorTwo: "vec3"
+        }, attributes: {
+            corners: "vec3"
+        },
+        vertexShader: `attribute vec2 corners;
+                        
+            varying vec2 tc;
+            
+            void main(void) {
+                gl_Position = vec4(corners, 0.0, 1.0);
+                tc = corners * 0.5 + 0.5;
+            }`,
+        fragmentShader: `precision highp float;
+            
+            #define MAX 10e10
+            #define PI 3.14159265359
+            #define rad(x) x * PI / 180.
+            #define ZERO vec3(0.0)          
+           
+            #define RED vec4(1.0, 0.0, 0.0, 1.0)
+            #define GREEN vec4(0.0, 1.0, 0.0, 1.0)         
+            
+            uniform vec3 camPos;            
+            uniform vec2 iResolution;
+            uniform float fov;
+            uniform float earthRadius;
+            uniform mat4 viewMatrix;
+            
+            uniform vec3 colorOne;
+            uniform vec3 colorTwo;
+                         
+            varying vec2 tc;
+                        
+            // compute the view ray in the camera coordinate
+            vec3 computeView(vec2 uv){
+                float w_h_ratio = iResolution.x / iResolution.y;   
+                float h = tan(rad(fov/2.));
+                return normalize(vec3(-w_h_ratio * h, -h, -1.) + vec3(uv.x * 2. * h * w_h_ratio, uv.y*2.*h, 0.));
+            }
+
+            // sphere of size ra centered at point ce
+            vec2 sphIntersect( in vec3 ro, in vec3 rd, in vec3 ce, float ra )
+            {
+                vec3 oc = ro - ce;
+                float b = dot( oc, rd );
+                float c = dot( oc, oc ) - ra * ra;
+                float h = b * b - c;
+                if( h < 0.0 ) return vec2(MAX); // no intersection
+                h = sqrt( h );
+                return vec2( -b-h, -b+h );
+            }
+            
+            mat3 transpose(mat3 matrix) {
+                vec3 row0 = matrix[0];
+                vec3 row1 = matrix[1];
+                vec3 row2 = matrix[2];
+                mat3 result = mat3(
+                    vec3(row0.x, row1.x, row2.x),
+                    vec3(row0.y, row1.y, row2.y),
+                    vec3(row0.z, row1.z, row2.z)
+                );
+                return result;
+            }
+            
+            float det(mat2 matrix) {
+                return matrix[0].x * matrix[1].y - matrix[0].y * matrix[1].x;
+            }
+            
+            mat3 inverse(mat3 matrix) {
+                vec3 row0 = matrix[0];
+                vec3 row1 = matrix[1];
+                vec3 row2 = matrix[2];
+            
+                vec3 minors0 = vec3(
+                    det(mat2(row1.y, row1.z, row2.y, row2.z)),
+                    det(mat2(row1.z, row1.x, row2.z, row2.x)),
+                    det(mat2(row1.x, row1.y, row2.x, row2.y))
+                );
+                vec3 minors1 = vec3(
+                    det(mat2(row2.y, row2.z, row0.y, row0.z)),
+                    det(mat2(row2.z, row2.x, row0.z, row0.x)),
+                    det(mat2(row2.x, row2.y, row0.x, row0.y))
+                );
+                vec3 minors2 = vec3(
+                    det(mat2(row0.y, row0.z, row1.y, row1.z)),
+                    det(mat2(row0.z, row0.x, row1.z, row1.x)),
+                    det(mat2(row0.x, row0.y, row1.x, row1.y))
+                );
+            
+                mat3 adj = transpose(mat3(minors0, minors1, minors2));
+            
+                return (1.0 / dot(row0, minors0)) * adj;
+            }
+            
+            void main(void) {
+            
+                vec3 dir = computeView(tc);
+                dir = inverse(mat3(viewMatrix)) * dir;
+                
+                vec2 ER = sphIntersect(camPos, dir, vec3(0.0), earthRadius);
+                
+                float bigRadius = earthRadius * 2.5;
+                vec3 bigCenter = normalize(camPos) * bigRadius * 1.3;                
+                               
+                vec2 BIG = sphIntersect(camPos, dir, bigCenter, bigRadius);
+                
+                float Ix = distance(camPos + dir * BIG.y, ZERO);               
+                
+                float maxI = sqrt(bigRadius * bigRadius + bigRadius * bigRadius);
+                                   
+                gl_FragColor = vec4(mix(colorOne, colorTwo, Ix / maxI), 1.0);
+            }`
+    });
+}

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/lib/js/control/Sun.js

@@ -0,0 +1,117 @@
+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 {
+    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;
+    }
+    oninit() {
+        this.planet.lightEnabled = true;
+        // sunlight initialization
+        this.sunlight.addTo(this.planet);
+        this.renderer.events.on("draw", this._draw, this);
+        if (!this._clockPtr) {
+            this._clockPtr = this.renderer.handler.defaultClock;
+        }
+    }
+    stop() {
+        this._stopped = true;
+        this.deactivate();
+    }
+    start() {
+        this._stopped = false;
+        this.activate();
+    }
+    onactivate() {
+        super.onactivate();
+        this._stopped = false;
+    }
+    bindClock(clock) {
+        this._clockPtr = clock;
+    }
+    _draw() {
+        if (!this._clockPtr)
+            return;
+        this._currDate = this._clockPtr.currentDate;
+        if (!this._stopped) {
+            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();
+                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 r = rot.slerp(Quat.IDENTITY, this._k).normalize();
+                    this.sunlight.setPosition3v(r.mulVec3(this.sunlight._position));
+                }
+                else {
+                    this.sunlight.setPosition3v(pos);
+                }
+            }
+            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 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) {
+                        this._lightOn = false;
+                        this._prevDate = this._currDate;
+                        this.sunlight.setPosition3v(getSunPosition(this._currDate));
+                        this._f = 0;
+                    }
+                }
+            }
+        }
+        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);
+        }
+    }
+}