@pirireis/webglobeplugins 0.9.11 → 0.9.13

package/programs/globeshell/wiggle/logic.js

@@ -1,14 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var util_1 = require("../../../util");
-var Logic = /** @class */ (function () {
-    function Logic() {
+import { createProgram } from '../../../util';
+export default class Logic {
+    constructor() {
         this.id = "GlobeShellProgram";
         this.description = "This program implements flyweight pattern for globe." +
             "At globes draw3D call stack, this program should be prior to any program that uses it." +
             "draw3D method of this object only sets Projetion, ModelView and Translate matrices and if the mode is 2D mapWH .";
     }
-    Logic.prototype.init = function (globe, gl) {
+    init(globe, gl) {
         this.gl = gl;
         this.globe = globe;
         this.programWrapper = this._createProgramWrapper();
@@ -17,20 +15,119 @@ var Logic = /** @class */ (function () {
         this.resize();
         this.updateTime(0);
         this.setMesh({ xRes: 64, yRes: 64, eastWestTied: false });
-    };
-    Logic.prototype._createProgramWrapper = function () {
-        var vertexShader = "#version 300 es\n        #define R 6378.137\n        #define PI 3.1415926535897932384626433832795\n        #define POLE 20037508.34\n        #define POLE_BY_PI 6366198.2\n        #define HALF_PI 1.5707963267948966192313216916398\n\n        uniform vec2 u_mesh_resolution;\n        \n        layout(std140) uniform ShellBlock {\n            vec2 u_grid_offset_rad;\n            vec2 u_grid_size_rad;\n            float u_height;\n            float u_wiggle;\n            float u_time;\n            float u_opacity;\n        };\n\n        uniform mat4 u_model_view_matrix;\n        uniform mat4 u_projection_matrix;\n        uniform vec3 u_translate;\n\n        uniform vec2 u_mapWH;\n        uniform vec2 u_scrWH;\n\n        uniform bool u_is3D; \n\n        out float v_opacity;\n        out vec2 v_texture_coordinate;\n        \n        vec2 f_texCoord(){\n\n            float x = mod( float(gl_VertexID), u_mesh_resolution.x ) / ( u_mesh_resolution.x - 1.0);\n            float y = floor( float(gl_VertexID) / u_mesh_resolution.x ) / ( u_mesh_resolution.y - 1.0);\n            return vec2(x, y);\n            //return vec2( fract( float(gl_VertexID) / u_mesh_resolution.x ), floor(float(gl_VertexID) / u_mesh_resolution.x) / u_mesh_resolution.y);\n        }\n\n        vec3 f_onSphere(vec2 texCoord){\n            float vert = (texCoord.y * u_grid_size_rad.y ) + u_grid_offset_rad.y;\n            float hor = (texCoord.x * u_grid_size_rad.x ) + u_grid_offset_rad.x;\n            float x = sin(vert) * cos(hor);\n            float y = sin(vert) * sin(hor);\n            float z = cos(vert);\n            return vec3(x, y, z);\n        }\n\n        vec2 f_onFlat(vec2 texCoord){\n            float x = (texCoord.x * u_grid_size_rad.x ) + u_grid_offset_rad.x;\n            float y = (texCoord.y * u_grid_size_rad.y ) + u_grid_offset_rad.y;\n\n\n            float mercX = x * POLE_BY_PI;\n            float mercY = log(tan(HALF_PI - y / 2.0 )) * POLE_BY_PI;\n\n            float normX = ( mercX - u_translate.x ) / u_mapWH.x;\n            float normY = ( mercY - u_translate.y ) / u_mapWH.y;\n            return vec2(normX, normY);\n        }       \n\n        vec3 f_position(vec3 unit_sphere_pos, float wiggle){\n            return unit_sphere_pos * (R + u_height + wiggle);\n        }\n        \n        float f_wiggle(vec2 texCoord){\n            float s_contrib = 0.6*sin(texCoord.x*2.0*PI + 3.0*u_time);\n            float t_contrib = 0.8*cos(texCoord.y*4.1 + 5.0*u_time);\n            return u_wiggle * s_contrib * t_contrib * sin(texCoord.y*PI*2.0);\n        }\n\n        void main() {\n            vec2 texCoord = f_texCoord();\n            if (u_is3D){\n                vec3 unit_sphere_pos = f_onSphere(texCoord);\n                float wiggle = f_wiggle(texCoord);\n                vec3 position = f_position(unit_sphere_pos, wiggle);\n                gl_Position = u_projection_matrix * u_model_view_matrix * vec4(position  - u_translate, 1.0);\n            }  else {\n                vec2 position = f_onFlat(texCoord);\n                gl_Position = u_projection_matrix * vec4(\n                    position.x * u_scrWH.x,\n                    (1.0 - position.y) * u_scrWH.y,\n                    0.0,\n                    1.0);\n            }\n            v_texture_coordinate = texCoord;\n            v_opacity = u_opacity;\n        }\n        ";
-        var fragmentShader = "#version 300 es\n        precision lowp float;\n        in vec2 v_texture_coordinate;\n        in float v_opacity;\n        uniform sampler2D u_texture;\n        out vec4 outColor;\n\n\n        void main() {\n           outColor = texture(u_texture, v_texture_coordinate);\n           outColor.a *= v_opacity;\n        }";
-        var gl = this.gl;
-        var program = (0, util_1.createProgram)(gl, vertexShader, fragmentShader);
-        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+    }
+    _createProgramWrapper() {
+        const vertexShader = `#version 300 es
+        #define R 6378.137
+        #define PI 3.1415926535897932384626433832795
+        #define POLE 20037508.34
+        #define POLE_BY_PI 6366198.2
+        #define HALF_PI 1.5707963267948966192313216916398
+
+        uniform vec2 u_mesh_resolution;
+        
+        layout(std140) uniform ShellBlock {
+            vec2 u_grid_offset_rad;
+            vec2 u_grid_size_rad;
+            float u_height;
+            float u_wiggle;
+            float u_time;
+            float u_opacity;
+        };
+
+        uniform mat4 u_model_view_matrix;
+        uniform mat4 u_projection_matrix;
+        uniform vec3 u_translate;
+
+        uniform vec2 u_mapWH;
+        uniform vec2 u_scrWH;
+
+        uniform bool u_is3D; 
+
+        out float v_opacity;
+        out vec2 v_texture_coordinate;
+        
+        vec2 f_texCoord(){
+
+            float x = mod( float(gl_VertexID), u_mesh_resolution.x ) / ( u_mesh_resolution.x - 1.0);
+            float y = floor( float(gl_VertexID) / u_mesh_resolution.x ) / ( u_mesh_resolution.y - 1.0);
+            return vec2(x, y);
+            //return vec2( fract( float(gl_VertexID) / u_mesh_resolution.x ), floor(float(gl_VertexID) / u_mesh_resolution.x) / u_mesh_resolution.y);
+        }
+
+        vec3 f_onSphere(vec2 texCoord){
+            float vert = (texCoord.y * u_grid_size_rad.y ) + u_grid_offset_rad.y;
+            float hor = (texCoord.x * u_grid_size_rad.x ) + u_grid_offset_rad.x;
+            float x = sin(vert) * cos(hor);
+            float y = sin(vert) * sin(hor);
+            float z = cos(vert);
+            return vec3(x, y, z);
+        }
+
+        vec2 f_onFlat(vec2 texCoord){
+            float x = (texCoord.x * u_grid_size_rad.x ) + u_grid_offset_rad.x;
+            float y = (texCoord.y * u_grid_size_rad.y ) + u_grid_offset_rad.y;
+
+
+            float mercX = x * POLE_BY_PI;
+            float mercY = log(tan(HALF_PI - y / 2.0 )) * POLE_BY_PI;
+
+            float normX = ( mercX - u_translate.x ) / u_mapWH.x;
+            float normY = ( mercY - u_translate.y ) / u_mapWH.y;
+            return vec2(normX, normY);
+        }       
+
+        vec3 f_position(vec3 unit_sphere_pos, float wiggle){
+            return unit_sphere_pos * (R + u_height + wiggle);
+        }
+        
+        float f_wiggle(vec2 texCoord){
+            float s_contrib = 0.6*sin(texCoord.x*2.0*PI + 3.0*u_time);
+            float t_contrib = 0.8*cos(texCoord.y*4.1 + 5.0*u_time);
+            return u_wiggle * s_contrib * t_contrib * sin(texCoord.y*PI*2.0);
+        }
+
+        void main() {
+            vec2 texCoord = f_texCoord();
+            if (u_is3D){
+                vec3 unit_sphere_pos = f_onSphere(texCoord);
+                float wiggle = f_wiggle(texCoord);
+                vec3 position = f_position(unit_sphere_pos, wiggle);
+                gl_Position = u_projection_matrix * u_model_view_matrix * vec4(position  - u_translate, 1.0);
+            }  else {
+                vec2 position = f_onFlat(texCoord);
+                gl_Position = u_projection_matrix * vec4(
+                    position.x * u_scrWH.x,
+                    (1.0 - position.y) * u_scrWH.y,
+                    0.0,
+                    1.0);
+            }
+            v_texture_coordinate = texCoord;
+            v_opacity = u_opacity;
+        }
+        `;
+        const fragmentShader = `#version 300 es
+        precision lowp float;
+        in vec2 v_texture_coordinate;
+        in float v_opacity;
+        uniform sampler2D u_texture;
+        out vec4 outColor;
+
+
+        void main() {
+           outColor = texture(u_texture, v_texture_coordinate);
+           outColor.a *= v_opacity;
+        }`;
+        const gl = this.gl;
+        const program = createProgram(gl, vertexShader, fragmentShader);
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(program);
         this.shellBlockBindingPoint = 0;
-        var shellBlockIndex = gl.getUniformBlockIndex(program, "ShellBlock");
+        const shellBlockIndex = gl.getUniformBlockIndex(program, "ShellBlock");
         gl.uniformBlockBinding(program, shellBlockIndex, this.shellBlockBindingPoint);
         gl.useProgram(currentProgram);
         return {
-            program: program,
+            program,
             u_model_view_matrix: gl.getUniformLocation(program, "u_model_view_matrix"),
             u_projection_matrix: gl.getUniformLocation(program, "u_projection_matrix"),
             u_translate: gl.getUniformLocation(program, "u_translate"),
@@ -40,22 +137,21 @@ var Logic = /** @class */ (function () {
             u_texture: gl.getUniformLocation(program, "u_texture"),
             u_mesh_resolution: gl.getUniformLocation(program, "u_mesh_resolution"),
         };
-    };
+    }
     // this method implements data part of flyweight pattern
-    Logic.prototype.getShellBlockBufferManager = function () {
+    getShellBlockBufferManager() {
         return new ShellBlockManager(this.gl);
-    };
-    Logic.prototype.updateTime = function (time) {
-        var _a = this, gl = _a.gl, programWrapper = _a.programWrapper;
-        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+    }
+    updateTime(time) {
+        const { gl, programWrapper } = this;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(programWrapper.program);
         gl.uniform1f(this.programWrapper.u_time, time);
         gl.useProgram(currentProgram);
-    };
-    Logic.prototype.setRotationAndTranslation = function (uProjectionMatrix, uModelViewMatrix, uTranslate, resetCurrentProgram) {
-        if (resetCurrentProgram === void 0) { resetCurrentProgram = false; }
-        var gl = this.gl;
-        var currentProgram = null;
+    }
+    setRotationAndTranslation(uProjectionMatrix, uModelViewMatrix, uTranslate, resetCurrentProgram = false) {
+        const gl = this.gl;
+        let currentProgram = null;
         if (resetCurrentProgram) {
             currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         }
@@ -67,35 +163,35 @@ var Logic = /** @class */ (function () {
         gl.uniform3fv(this.programWrapper.u_translate, this._transformArray);
         if (resetCurrentProgram)
             gl.useProgram(currentProgram);
-    };
-    Logic.prototype.setGeometry = function () {
-        var _a = this, globe = _a.globe, gl = _a.gl;
-        var _b = this.programWrapper, u_is3D = _b.u_is3D, u_scrWH = _b.u_scrWH, program = _b.program;
-        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        var is3D = this.globe.api_GetCurrentGeometry() === 0;
+    }
+    setGeometry() {
+        const { globe, gl } = this;
+        const { u_is3D, u_scrWH, program } = this.programWrapper;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        const is3D = this.globe.api_GetCurrentGeometry() === 0;
         gl.useProgram(program);
         if (globe.api_GetCurrentGeometry() === globe.api_GeometryTypes().FLAT) {
             gl.uniform2f(u_scrWH, globe.api_ScrW(), globe.api_ScrH());
         }
         gl.uniform1i(u_is3D, is3D);
         gl.useProgram(currentProgram);
-    };
-    Logic.prototype.resize = function () {
-        var _a = this, gl = _a.gl, globe = _a.globe;
+    }
+    resize() {
+        const { gl, globe } = this;
         if (!globe)
             return;
-        var _b = this.programWrapper, program = _b.program, u_scrWH = _b.u_scrWH;
-        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        const { program, u_scrWH } = this.programWrapper;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(program);
         if (globe.api_GetCurrentGeometry() === globe.api_GeometryTypes().FLAT) {
             gl.uniform2f(u_scrWH, globe.api_ScrW(), globe.api_ScrH());
         }
         gl.useProgram(currentProgram);
-    };
+    }
     // only sets data does not draw
-    Logic.prototype.draw3D = function (uProjectionMatrix, uModelViewMatrix, uTranslate) {
-        var _a = this, gl = _a.gl, globe = _a.globe;
-        var _b = this.programWrapper, program = _b.program, u_model_view_matrix = _b.u_model_view_matrix, u_projection_matrix = _b.u_projection_matrix, u_translate = _b.u_translate;
+    draw3D(uProjectionMatrix, uModelViewMatrix, uTranslate) {
+        const { gl, globe } = this;
+        const { program, u_model_view_matrix, u_projection_matrix, u_translate } = this.programWrapper;
         gl.disable(gl.DEPTH_TEST);
         gl.useProgram(program);
         gl.uniformMatrix4fv(u_projection_matrix, false, uProjectionMatrix);
@@ -103,15 +199,14 @@ var Logic = /** @class */ (function () {
         // this._transformArray.set([], 0);
         gl.uniform3f(u_translate, uTranslate.x, uTranslate.y, uTranslate.z);
         if (globe.api_GetCurrentGeometry() === 1) {
-            var _c = globe.api_GetCurrentWorldWH(), width = _c.width, height = _c.height;
+            const { width, height } = globe.api_GetCurrentWorldWH();
             gl.uniform2fv(this.programWrapper.u_mapWH, [width, height]);
         }
         gl.enable(gl.DEPTH_TEST);
-    };
-    Logic.prototype.draw = function (texture, shellBlockDataManager, drawLines) {
-        if (drawLines === void 0) { drawLines = false; }
-        var _a = this, gl = _a.gl, programWrapper = _a.programWrapper, _vao = _a._vao, _drawCount = _a._drawCount;
-        var program = programWrapper.program, u_texture = programWrapper.u_texture;
+    }
+    draw(texture, shellBlockDataManager, drawLines = false) {
+        const { gl, programWrapper, _vao, _drawCount } = this;
+        const { program, u_texture } = programWrapper;
         gl.useProgram(program);
         gl.bindVertexArray(_vao);
         gl.activeTexture(gl.TEXTURE0);
@@ -124,39 +219,38 @@ var Logic = /** @class */ (function () {
         gl.drawElements(gl.TRIANGLES, _drawCount, gl.UNSIGNED_SHORT, 0);
         shellBlockDataManager.unbind();
         gl.bindVertexArray(null);
-    };
-    Logic.prototype.free = function () {
-        var _a = this, gl = _a.gl, programWrapper = _a.programWrapper, _vao = _a._vao, _indexBuffer = _a._indexBuffer;
+    }
+    free() {
+        const { gl, programWrapper, _vao, _indexBuffer } = this;
         gl.deleteBuffer(_indexBuffer);
         gl.deleteVertexArray(_vao);
         gl.deleteProgram(programWrapper.program);
-    };
-    Logic.prototype.setMesh = function (_a) {
-        var xRes = _a.xRes, yRes = _a.yRes, eastWestTied = _a.eastWestTied;
+    }
+    setMesh({ xRes, yRes, eastWestTied }) {
         this._xRes = xRes;
         this._yRes = yRes;
-        var _vao = this._meshUP(xRes, yRes, eastWestTied)._vao;
+        const { _vao } = this._meshUP(xRes, yRes, eastWestTied);
         this._vao = _vao;
         this._setUMeshResolution(xRes, yRes);
-    };
-    Logic.prototype._setUMeshResolution = function (xRes, yRes) {
-        var _a = this, gl = _a.gl, programWrapper = _a.programWrapper;
-        var u_mesh_resolution = programWrapper.u_mesh_resolution;
-        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+    }
+    _setUMeshResolution(xRes, yRes) {
+        const { gl, programWrapper } = this;
+        const { u_mesh_resolution } = programWrapper;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(programWrapper.program);
         gl.uniform2f(u_mesh_resolution, xRes, yRes);
         gl.useProgram(currentProgram);
         this._drawCount = 6 * ((xRes - 1) * (yRes - 1));
-    };
-    Logic.prototype._meshUP = function (xRes, yRes, eastWestTied) {
+    }
+    _meshUP(xRes, yRes, eastWestTied) {
         this._drawCount = 6 * ((xRes - 1) * (yRes - 1));
-        var indices = new Uint16Array(this._drawCount);
+        const indices = new Uint16Array(this._drawCount);
         {
-            var indicesIndex = 0;
-            var index = 0;
-            for (var j = 0; j < yRes - 1; j++) {
-                for (var i = 0; i < xRes - 1; i++) {
-                    var ind = index + i;
+            let indicesIndex = 0;
+            let index = 0;
+            for (let j = 0; j < yRes - 1; j++) {
+                for (let i = 0; i < xRes - 1; i++) {
+                    const ind = index + i;
                     indices[indicesIndex++] = ind + xRes;
                     indices[indicesIndex++] = ind + 1;
                     indices[indicesIndex++] = ind;
@@ -167,9 +261,9 @@ var Logic = /** @class */ (function () {
                 index += xRes;
             }
             if (eastWestTied) {
-                var left = (yRes - 1);
-                var right = 0;
-                for (var i = 0; i < xRes - 1; i++) {
+                let left = (yRes - 1);
+                let right = 0;
+                for (let i = 0; i < xRes - 1; i++) {
                     indices[indicesIndex++] = left + xRes;
                     indices[indicesIndex++] = right;
                     indices[indicesIndex++] = left;
@@ -181,49 +275,46 @@ var Logic = /** @class */ (function () {
                 }
             }
         }
-        var gl = this.gl;
-        var _vao = gl.createVertexArray();
+        const gl = this.gl;
+        const _vao = gl.createVertexArray();
         gl.bindVertexArray(_vao);
-        var indexBuffer = gl.createBuffer();
+        const indexBuffer = gl.createBuffer();
         this._indexBuffer = indexBuffer;
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
         gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW);
         gl.bindVertexArray(null);
-        return { _vao: _vao };
-    };
-    return Logic;
-}());
-exports.default = Logic;
-var ShellBlockManager = /** @class */ (function () {
-    function ShellBlockManager(gl) {
+        return { _vao };
+    }
+}
+class ShellBlockManager {
+    constructor(gl) {
         this.gl = gl;
         this.buffer = gl.createBuffer();
         gl.bindBuffer(gl.UNIFORM_BUFFER, this.buffer);
         gl.bufferData(gl.UNIFORM_BUFFER, 32, gl.DYNAMIC_DRAW);
         gl.bindBuffer(gl.UNIFORM_BUFFER, null);
     }
-    ShellBlockManager.prototype.update = function (_a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.gridSizeRad, gridSizeRad = _c === void 0 ? null : _c, _d = _b.gridOffsetRad, gridOffsetRad = _d === void 0 ? null : _d, _e = _b.height, height = _e === void 0 ? null : _e, _f = _b.wiggleInKM, wiggleInKM = _f === void 0 ? null : _f, _g = _b.innerTime, innerTime = _g === void 0 ? null : _g, _h = _b.opacity, opacity = _h === void 0 ? null : _h;
-        var _j = this, gl = _j.gl, buffer = _j.buffer;
+    update({ gridSizeRad = null, gridOffsetRad = null, height = null, wiggleInKM = null, innerTime = null, opacity = null } = {}) {
+        const { gl, buffer } = this;
         gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
         if (gridOffsetRad !== null) {
-            var offset = new Float32Array(gridOffsetRad);
+            const offset = new Float32Array(gridOffsetRad);
             gl.bufferSubData(gl.UNIFORM_BUFFER, 0, offset);
         }
         if (gridSizeRad !== null) {
-            var size = new Float32Array(gridSizeRad);
+            const size = new Float32Array(gridSizeRad);
             gl.bufferSubData(gl.UNIFORM_BUFFER, 8, size);
         }
         if (height !== null) {
-            var heightArray = new Float32Array([height]);
+            const heightArray = new Float32Array([height]);
             gl.bufferSubData(gl.UNIFORM_BUFFER, 16, heightArray);
         }
         if (wiggleInKM !== null) {
-            var wiggleArray = new Float32Array([wiggleInKM]);
+            const wiggleArray = new Float32Array([wiggleInKM]);
             gl.bufferSubData(gl.UNIFORM_BUFFER, 20, wiggleArray);
         }
         if (innerTime !== null) {
-            var innerTimeArray = new Float32Array([innerTime]);
+            const innerTimeArray = new Float32Array([innerTime]);
             gl.bufferSubData(gl.UNIFORM_BUFFER, 24, innerTimeArray);
         }
         if (opacity !== null) {
@@ -231,22 +322,21 @@ var ShellBlockManager = /** @class */ (function () {
                 console.warn('Invalid opacity value');
                 return;
             }
-            var op = new Float32Array([opacity]);
+            const op = new Float32Array([opacity]);
             gl.bufferSubData(gl.UNIFORM_BUFFER, 28, op);
         }
         gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    };
-    ShellBlockManager.prototype.bind = function () {
-        var _a = this, gl = _a.gl, buffer = _a.buffer;
+    }
+    bind() {
+        const { gl, buffer } = this;
         gl.bindBufferBase(gl.UNIFORM_BUFFER, this.shellBlockBindingPoint, buffer);
-    };
-    ShellBlockManager.prototype.free = function () {
-        var _a = this, gl = _a.gl, buffer = _a.buffer;
+    }
+    free() {
+        const { gl, buffer } = this;
         gl.deleteBuffer(buffer);
-    };
-    ShellBlockManager.prototype.unbind = function () {
-        var gl = this.gl;
+    }
+    unbind() {
+        const { gl } = this;
         gl.bindBufferBase(gl.UNIFORM_BUFFER, this.shellBlockBindingPoint, null);
-    };
-    return ShellBlockManager;
-}());
+    }
+}

package/programs/globeshell/wiggle/object.js

@@ -1,74 +1,66 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var programcache_1 = require("../../programcache");
-var logic_1 = __importDefault(require("./logic"));
-var GlobeShell = /** @class */ (function () {
-    function GlobeShell(gl, globe, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.minLon, minLon = _c === void 0 ? -180 : _c, _d = _b.maxLon, maxLon = _d === void 0 ? 180 : _d, _e = _b.minLat, minLat = _e === void 0 ? -90 : _e, _f = _b.maxLat, maxLat = _f === void 0 ? 90 : _f, _g = _b.height, height = _g === void 0 ? 0 : _g, _h = _b.u_opacity, u_opacity = _h === void 0 ? 1 : _h, _j = _b.wiggleInKM, wiggleInKM = _j === void 0 ? 0 : _j, _k = _b.wiggleSpeed, wiggleSpeed = _k === void 0 ? 0 : _k;
+import { globeProgramCache } from '../../programcache';
+import GlobeShellProgram from './logic';
+export default class GlobeShell {
+    constructor(gl, globe, { minLon = -180, maxLon = 180, minLat = -90, maxLat = 90, height = 0, u_opacity = 1, wiggleInKM = 0, wiggleSpeed = 0,
+    // eastWestTied, Not implemented yet
+     } = {}) {
         this.gl = gl;
         this.globe = globe;
-        this.program = programcache_1.globeProgramCache.getProgram(globe, logic_1.default);
+        this.program = globeProgramCache.getProgram(globe, GlobeShellProgram);
         this.shellBlockManager = this.program.getShellBlockBufferManager();
         this.update = this.shellBlockManager.update.bind(this.shellBlockManager);
         this.innerTime = 0;
-        this.setBBox({ minLon: minLon, maxLon: maxLon, minLat: minLat, maxLat: maxLat });
+        this.setBBox({ minLon, maxLon, minLat, maxLat });
         this.setOpacity(u_opacity);
         this.setHeight(height);
-        this.setWiggle({ wiggleSpeed: wiggleSpeed, wiggleInKM: wiggleInKM });
+        this.setWiggle({ wiggleSpeed, wiggleInKM });
     }
-    GlobeShell.prototype.setTexture = function (texture) {
+    setTexture(texture) {
         this.texture = texture;
         this.globe.DrawRender();
-    };
-    GlobeShell.prototype.setHeight = function (height) {
-        this.shellBlockManager.update({ height: height });
+    }
+    setHeight(height) {
+        this.shellBlockManager.update({ height });
         this.globe.DrawRender();
-    };
-    GlobeShell.prototype.setOpacity = function (opacity) {
-        this.shellBlockManager.update({ opacity: opacity });
+    }
+    setOpacity(opacity) {
+        this.shellBlockManager.update({ opacity });
         this.globe.DrawRender();
-    };
-    GlobeShell.prototype.setBBox = function (_a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.minLon, minLon = _c === void 0 ? -180 : _c, _d = _b.maxLon, maxLon = _d === void 0 ? 180 : _d, _e = _b.minLat, minLat = _e === void 0 ? -90 : _e, _f = _b.maxLat, maxLat = _f === void 0 ? 90 : _f;
-        this.bbox = { minLon: minLon, maxLon: maxLon, minLat: minLat, maxLat: maxLat };
+    }
+    setBBox({ minLon = -180, maxLon = 180, minLat = -90, maxLat = 90 } = {}) {
+        this.bbox = { minLon, maxLon, minLat, maxLat };
         // x
-        var horOffset = (minLon) * Math.PI / 180;
-        var horSize = (maxLon - minLon) * Math.PI / 180;
+        const horOffset = (minLon) * Math.PI / 180;
+        const horSize = (maxLon - minLon) * Math.PI / 180;
         // y
-        var vertOffset = (90 - maxLat) * Math.PI / 180;
-        var vertSize = (maxLat - minLat) * Math.PI / 180;
-        var offset_rad = new Float32Array([horOffset, vertOffset]);
-        var size_rad = new Float32Array([horSize, vertSize]);
+        const vertOffset = (90 - maxLat) * Math.PI / 180;
+        const vertSize = (maxLat - minLat) * Math.PI / 180;
+        const offset_rad = new Float32Array([horOffset, vertOffset]);
+        const size_rad = new Float32Array([horSize, vertSize]);
         this.shellBlockManager.update({ gridSizeRad: size_rad, gridOffsetRad: offset_rad });
         this.globe.DrawRender();
-    };
-    GlobeShell.prototype.setWiggle = function (_a) {
-        var _b = _a.wiggleSpeed, wiggleSpeed = _b === void 0 ? null : _b, _c = _a.wiggleInKM, wiggleInKM = _c === void 0 ? null : _c;
+    }
+    setWiggle({ wiggleSpeed = null, wiggleInKM = null }) {
         if (wiggleInKM !== null)
             this.wiggleInKM = wiggleInKM;
         if (wiggleSpeed !== null)
             this.wiggleSpeed = wiggleSpeed;
-        this.shellBlockManager.update({ wiggleInKM: wiggleInKM });
-    };
+        this.shellBlockManager.update({ wiggleInKM });
+    }
     /**
      *
      * @param {*} program  modelView, projection, translate, mapWH, scrWH, should be set before calling this function
      */
-    GlobeShell.prototype.draw = function () {
+    draw() {
         this.program.draw(this.texture, this.shellBlockManager);
         if (this.wiggleInKM > 0 && this.wiggleSpeed > 0) {
             this.innerTime += this.wiggleSpeed;
             this.shellBlockManager.update({ innerTime: this.innerTime });
             this.globe.DrawRender();
         }
-    };
-    GlobeShell.prototype.free = function () {
-        programcache_1.globeProgramCache.releaseProgram(this.globe, logic_1.default);
+    }
+    free() {
+        globeProgramCache.releaseProgram(this.globe, GlobeShellProgram);
         this.shellBlockManager.free();
-    };
-    return GlobeShell;
-}());
-exports.default = GlobeShell;
+    }
+}

package/programs/helpers/blender/program.js

@@ -1,19 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var util_1 = require("../util");
+import { createProgram } from "../util";
 /**
  * Blends two float32textures with given ratio.
  */
-var vertexShader = "#version 300 es\nin vec2 a_position;\nout vec2 v_texCoord;\nvoid main() {\n    gl_Position = vec4(a_position, 0.0, 1.0);\n    v_texCoord = a_position * 0.5 + 0.5;\n}\n";
-var fragmentShader = "#version 300 es\nuniform sampler2D u_texture0;\nuniform sampler2D u_texture1;\nuniform float u_ratio;\nin v_texCoord;\nout vec4 outColor;\nvoid main() {\n    vec4 color0 = texture(u_texture0, v_texCoord);\n    vec4 color1 = texture(u_texture1, v_texCoord);\n    outColor = mix(color0, color1, u_ratio);\n}\n";
-var BlenderProgram = /** @class */ (function () {
-    function BlenderProgram(gl) {
+const vertexShader = `#version 300 es
+in vec2 a_position;
+out vec2 v_texCoord;
+void main() {
+    gl_Position = vec4(a_position, 0.0, 1.0);
+    v_texCoord = a_position * 0.5 + 0.5;
+}
+`;
+const fragmentShader = `#version 300 es
+uniform sampler2D u_texture0;
+uniform sampler2D u_texture1;
+uniform float u_ratio;
+in v_texCoord;
+out vec4 outColor;
+void main() {
+    vec4 color0 = texture(u_texture0, v_texCoord);
+    vec4 color1 = texture(u_texture1, v_texCoord);
+    outColor = mix(color0, color1, u_ratio);
+}
+`;
+export default class BlenderProgram {
+    constructor(gl) {
         this.gl = gl;
         this.programWrapper = this._createProgramWrapper();
     }
-    BlenderProgram.prototype._craeteProgramWrapper = function () {
-        var gl = this.gl;
-        var program = (0, util_1.createProgram)(gl, vertexShader, fragmentShader);
+    _craeteProgramWrapper() {
+        const gl = this.gl;
+        const program = createProgram(gl, vertexShader, fragmentShader);
         this.vao = gl.createVertexArray();
         gl.bindVertexArray(this.vao);
         this._buffer = gl.createBuffer();
@@ -30,10 +46,10 @@ var BlenderProgram = /** @class */ (function () {
         gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
         gl.bindVertexArray(null);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        return { program: program, uniforms: { u_texture0: gl.getUniformLocation(program, 'u_texture0'), u_texture1: gl.getUniformLocation(program, 'u_texture1'), u_ratio: gl.getUniformLocation(program, 'u_ratio') } };
-    };
-    BlenderProgram.prototype.draw = function (ratio, texture0, texture1) {
-        var gl = this.gl;
+        return { program, uniforms: { u_texture0: gl.getUniformLocation(program, 'u_texture0'), u_texture1: gl.getUniformLocation(program, 'u_texture1'), u_ratio: gl.getUniformLocation(program, 'u_ratio') } };
+    }
+    draw(ratio, texture0, texture1) {
+        const gl = this.gl;
         gl.useProgram(this.programWrapper.program);
         gl.bindVertexArray(this.vao);
         gl.activeTexture(gl.TEXTURE1);
@@ -45,10 +61,10 @@ var BlenderProgram = /** @class */ (function () {
         gl.uniform1f(this.programWrapper.uniforms.u_ratio, ratio);
         gl.drawArrays(gl.TRIANGLES, 0, 6);
         gl.bindVertexArray(null);
-    };
-    BlenderProgram.prototype.createFloat32Texture = function (width, height) {
-        var gl = this.gl;
-        var texture = gl.createTexture();
+    }
+    createFloat32Texture(width, height) {
+        const gl = this.gl;
+        const texture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.texImage2D(gl.TEXTURE_2D, 0, gl.R32F, width, height, 0, gl.RED, gl.FLOAT, null);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
@@ -56,7 +72,5 @@ var BlenderProgram = /** @class */ (function () {
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
         return texture;
-    };
-    return BlenderProgram;
-}());
-exports.default = BlenderProgram;
+    }
+}

package/programs/helpers/fadeaway/index.js

@@ -1,7 +1,2 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var object_1 = __importDefault(require("./object"));
-exports.default = object_1.default;
+import FadeAway from './object';
+export default FadeAway;