@pirireis/webglobeplugins 0.15.35 → 0.16.0

package/dist/programs/float2legendwithratio/object.js

@@ -0,0 +1,104 @@
+import Float2LegentWithRatioProgram from './logic';
+import { glProgramCache } from '../programcache';
+// Uniform Buffer Objects use this 
+export default class DataObject {
+    constructor(gl, { width = 1, height = 1, texture0 = null, texture1 = null, colorRampTexture = null, colorRampRange = null, escapeValue = 99999, blendRatio = 0.0, minMaxEdges = null, } = {}) {
+        this.gl = gl;
+        this.programlogic = glProgramCache.getProgram(gl, Float2LegentWithRatioProgram);
+        this.heatParametersBlockManager = this.programlogic.getUniformBlockManager();
+        this.width = width;
+        this.height = height;
+        this.texture0 = texture0 || this._createColorRampTexture(width, height);
+        this.texture1 = texture1 || this._createColorRampTexture(width, height);
+        this.colorRampTexture = colorRampTexture || this._createColorRampTexture();
+        this.minMaxEdges = minMaxEdges || new Float32Array([-99999, 99999]);
+        this.heatParametersBlockManager.update({
+            escape_value: escapeValue,
+            blend_ratio: blendRatio,
+            min_max: minMaxEdges,
+            color_ramp_range: colorRampRange
+        });
+    }
+    _bindBlock() {
+        const gl = this.gl;
+        const program = this.programlogic.programWrapper.program;
+        gl.uniformBlockBinding(program, gl.getUniformBlockIndex(program, 'Block'), 0);
+    }
+    _createColorRampTexture() {
+        const { gl } = this;
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        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);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        return texture;
+    }
+    setBlendRatio(ratio) {
+        if (ratio < 0 || ratio > 1) {
+            console.warn('Invalid blend ratio');
+            return;
+        }
+        this.heatParametersBlockManager.update({ blend_ratio: ratio });
+    }
+    setEscapeValue(value) {
+        this.heatParametersBlockManager.update({ escape_value: value });
+    }
+    setTexture0(texture) {
+        this.texture0 = texture;
+    }
+    setTexture1(texture) {
+        this.texture1 = texture;
+    }
+    setColorRampTexture(texture) {
+        this.colorRampTexture = texture;
+    }
+    setDataWidthHeight(width, height) {
+        this.width = width;
+        this.height = height;
+    }
+    setFloatTextureData(data0, data1, width, height, yFlip = false) {
+        const { texture0, texture1, gl } = this;
+        gl.bindTexture(gl.TEXTURE_2D, texture0);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, yFlip);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.R16F, width, height, 0, gl.RED, gl.FLOAT, data0);
+        gl.bindTexture(gl.TEXTURE_2D, texture1);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.R16F, width, height, 0, gl.RED, gl.FLOAT, data1);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+    }
+    discard() {
+        this.heatParametersBlockManager.update({ blend_ratio: -1 });
+    }
+    setColorRampTextureData(data, size) {
+        const { gl, colorRampTexture } = this;
+        gl.bindTexture(gl.TEXTURE_2D, colorRampTexture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
+    }
+    setColorRampRange(min, max) {
+        if (min > max) {
+            console.warn('Invalid min max values');
+            return;
+        }
+        const range = max - min;
+        this.heatParametersBlockManager.update({ color_ramp_range: new Float32Array([min, range]) });
+    }
+    setMinMaxEdges(min, max) {
+        if (min)
+            this.minMaxEdges[0] = min;
+        if (max)
+            this.minMaxEdges[1] = max;
+        this.heatParametersBlockManager.update({ min_max: this.minMaxEdges });
+    }
+    draw() {
+        this.programlogic.draw(this.texture0, this.texture1, this.colorRampTexture, this.heatParametersBlockManager);
+    }
+    free() {
+        const { gl, texture0, texture1, colorRampTexture } = this;
+        gl.deleteTexture(texture0);
+        gl.deleteTexture(texture1);
+        gl.deleteTexture(colorRampTexture);
+        glProgramCache.releaseProgram(this.gl, Float2LegentWithRatioProgram);
+        this.heatParametersBlockManager.free();
+    }
+}

package/dist/programs/globe-util/is-globe-moved.js

@@ -0,0 +1,19 @@
+import { noRegisterGlobeProgramCache } from "../programcache";
+class IsGlobeMoved {
+    constructor(globe) {
+        this.globe = globe;
+        this._lastLOD = globe.api_GetCurrentLODWithDecimal();
+    }
+    isMoved() {
+        const globe = this.globe;
+        if (globe.api_IsScreenMoving() || this._lastLOD != globe.api_GetCurrentLODWithDecimal()) {
+            this._lastLOD = globe.api_GetCurrentLODWithDecimal();
+            return true;
+        }
+        return false;
+    }
+}
+const IsGlobeMovedCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, IsGlobeMoved),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, IsGlobeMoved)
+});

package/dist/programs/globeshell/index.js

@@ -0,0 +1,2 @@
+import GlobeShellWiggle from "./globeshell/wiggle";
+export { GlobeShellWiggle };

package/dist/programs/globeshell/wiggle/index.js

@@ -0,0 +1,2 @@
+import GlobeShellWiggle from './object';
+export { GlobeShellWiggle };

package/dist/programs/globeshell/wiggle/logic.js

@@ -0,0 +1,342 @@
+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 .";
+    }
+    init(globe, gl) {
+        this.gl = gl;
+        this.globe = globe;
+        this.programWrapper = this._createProgramWrapper();
+        this._transformArray = new Float32Array(3);
+        this.setGeometry();
+        this.resize();
+        this.updateTime(0);
+        this.setMesh({ xRes: 64, yRes: 64, eastWestTied: false });
+    }
+    _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;
+        const shellBlockIndex = gl.getUniformBlockIndex(program, "ShellBlock");
+        gl.uniformBlockBinding(program, shellBlockIndex, this.shellBlockBindingPoint);
+        gl.useProgram(currentProgram);
+        return {
+            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"),
+            u_is3D: gl.getUniformLocation(program, "u_is3D"),
+            u_scrWH: gl.getUniformLocation(program, "u_scrWH"),
+            u_mapWH: gl.getUniformLocation(program, "u_mapWH"),
+            u_texture: gl.getUniformLocation(program, "u_texture"),
+            u_mesh_resolution: gl.getUniformLocation(program, "u_mesh_resolution"),
+        };
+    }
+    // this method implements data part of flyweight pattern
+    getShellBlockBufferManager() {
+        return new ShellBlockManager(this.gl);
+    }
+    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);
+    }
+    setRotationAndTranslation(uProjectionMatrix, uModelViewMatrix, uTranslate, resetCurrentProgram = false) {
+        const gl = this.gl;
+        let currentProgram = null;
+        if (resetCurrentProgram) {
+            currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        }
+        ;
+        gl.useProgram(this.programWrapper.program);
+        gl.uniformMatrix4fv(this.programWrapper.u_projection_matrix, false, uProjectionMatrix);
+        gl.uniformMatrix4fv(this.programWrapper.u_model_view_matrix, false, uModelViewMatrix);
+        this._transformArray.set([uTranslate.x, uTranslate.y, uTranslate.z], 0);
+        gl.uniform3fv(this.programWrapper.u_translate, this._transformArray);
+        if (resetCurrentProgram)
+            gl.useProgram(currentProgram);
+    }
+    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);
+    }
+    resize() {
+        const { gl, globe } = this;
+        if (!globe)
+            return;
+        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
+    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);
+        gl.uniformMatrix4fv(u_model_view_matrix, false, uModelViewMatrix);
+        // this._transformArray.set([], 0);
+        gl.uniform3f(u_translate, uTranslate.x, uTranslate.y, uTranslate.z);
+        if (globe.api_GetCurrentGeometry() === 1) {
+            const { width, height } = globe.api_GetCurrentWorldWH();
+            gl.uniform2fv(this.programWrapper.u_mapWH, [width, height]);
+        }
+        gl.enable(gl.DEPTH_TEST);
+    }
+    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);
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.uniform1i(u_texture, 0);
+        shellBlockDataManager.bind();
+        if (drawLines)
+            gl.drawElements(gl.LINES, _drawCount, gl.UNSIGNED_SHORT, 0);
+        gl.clearColor(0, 0, 0, 0);
+        gl.drawElements(gl.TRIANGLES, _drawCount, gl.UNSIGNED_SHORT, 0);
+        shellBlockDataManager.unbind();
+        gl.bindVertexArray(null);
+    }
+    free() {
+        const { gl, programWrapper, _vao, _indexBuffer } = this;
+        gl.deleteBuffer(_indexBuffer);
+        gl.deleteVertexArray(_vao);
+        gl.deleteProgram(programWrapper.program);
+    }
+    setMesh({ xRes, yRes, eastWestTied }) {
+        this._xRes = xRes;
+        this._yRes = yRes;
+        const { _vao } = this._meshUP(xRes, yRes, eastWestTied);
+        this._vao = _vao;
+        this._setUMeshResolution(xRes, yRes);
+    }
+    _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));
+    }
+    _meshUP(xRes, yRes, eastWestTied) {
+        this._drawCount = 6 * ((xRes - 1) * (yRes - 1));
+        const indices = new Uint16Array(this._drawCount);
+        {
+            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;
+                    indices[indicesIndex++] = ind + xRes + 1;
+                    indices[indicesIndex++] = ind + 1;
+                    indices[indicesIndex++] = ind + xRes;
+                }
+                index += xRes;
+            }
+            if (eastWestTied) {
+                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;
+                    indices[indicesIndex++] = right + xRes;
+                    indices[indicesIndex++] = right;
+                    indices[indicesIndex++] = left + xRes;
+                    left += xRes;
+                    right += xRes;
+                }
+            }
+        }
+        const gl = this.gl;
+        const _vao = gl.createVertexArray();
+        gl.bindVertexArray(_vao);
+        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 };
+    }
+}
+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);
+    }
+    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) {
+            const offset = new Float32Array(gridOffsetRad);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, offset);
+        }
+        if (gridSizeRad !== null) {
+            const size = new Float32Array(gridSizeRad);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 8, size);
+        }
+        if (height !== null) {
+            const heightArray = new Float32Array([height]);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 16, heightArray);
+        }
+        if (wiggleInKM !== null) {
+            const wiggleArray = new Float32Array([wiggleInKM]);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 20, wiggleArray);
+        }
+        if (innerTime !== null) {
+            const innerTimeArray = new Float32Array([innerTime]);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 24, innerTimeArray);
+        }
+        if (opacity !== null) {
+            if (opacity < 0 || opacity > 1) {
+                console.warn('Invalid opacity value');
+                return;
+            }
+            const op = new Float32Array([opacity]);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 28, op);
+        }
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+    bind() {
+        const { gl, buffer } = this;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.shellBlockBindingPoint, buffer);
+    }
+    free() {
+        const { gl, buffer } = this;
+        gl.deleteBuffer(buffer);
+    }
+    unbind() {
+        const { gl } = this;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.shellBlockBindingPoint, null);
+    }
+}

package/dist/programs/globeshell/wiggle/object.js

@@ -0,0 +1,66 @@
+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 = globeProgramCache.getProgram(globe, GlobeShellProgram);
+        this.shellBlockManager = this.program.getShellBlockBufferManager();
+        this.update = this.shellBlockManager.update.bind(this.shellBlockManager);
+        this.innerTime = 0;
+        this.setBBox({ minLon, maxLon, minLat, maxLat });
+        this.setOpacity(u_opacity);
+        this.setHeight(height);
+        this.setWiggle({ wiggleSpeed, wiggleInKM });
+    }
+    setTexture(texture) {
+        this.texture = texture;
+        this.globe.DrawRender();
+    }
+    setHeight(height) {
+        this.shellBlockManager.update({ height });
+        this.globe.DrawRender();
+    }
+    setOpacity(opacity) {
+        this.shellBlockManager.update({ opacity });
+        this.globe.DrawRender();
+    }
+    setBBox({ minLon = -180, maxLon = 180, minLat = -90, maxLat = 90 } = {}) {
+        this.bbox = { minLon, maxLon, minLat, maxLat };
+        // x
+        const horOffset = (minLon) * Math.PI / 180;
+        const horSize = (maxLon - minLon) * Math.PI / 180;
+        // y
+        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();
+    }
+    setWiggle({ wiggleSpeed = null, wiggleInKM = null }) {
+        if (wiggleInKM !== null)
+            this.wiggleInKM = wiggleInKM;
+        if (wiggleSpeed !== null)
+            this.wiggleSpeed = wiggleSpeed;
+        this.shellBlockManager.update({ wiggleInKM });
+    }
+    /**
+     *
+     * @param {*} program  modelView, projection, translate, mapWH, scrWH, should be set before calling this 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();
+        }
+    }
+    free() {
+        globeProgramCache.releaseProgram(this.globe, GlobeShellProgram);
+        this.shellBlockManager.free();
+    }
+}

package/dist/programs/helpers/blender/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/programs/helpers/blender/program.js

@@ -0,0 +1,76 @@
+import { createProgram } from "../util";
+/**
+ * Blends two float32textures with given ratio.
+ */
+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();
+    }
+    _craeteProgramWrapper() {
+        const gl = this.gl;
+        const program = createProgram(gl, vertexShader, fragmentShader);
+        this.vao = gl.createVertexArray();
+        gl.bindVertexArray(this.vao);
+        this._buffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+            -1, -1,
+            1, -1,
+            -1, 1,
+            -1, 1,
+            1, -1,
+            1, 1,
+        ]), gl.STATIC_DRAW);
+        gl.enableVertexAttribArray(0);
+        gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        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);
+        gl.bindTexture(gl.TEXTURE_2D, texture1);
+        gl.uniform1i(this.programWrapper.uniforms.u_texture1, 1);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, texture0);
+        gl.uniform1i(this.programWrapper.uniforms.u_texture0, 0);
+        gl.uniform1f(this.programWrapper.uniforms.u_ratio, ratio);
+        gl.drawArrays(gl.TRIANGLES, 0, 6);
+        gl.bindVertexArray(null);
+    }
+    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);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        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;
+    }
+}

package/dist/programs/helpers/fadeaway/index.js

@@ -0,0 +1,2 @@
+import FadeAway from './object';
+export default FadeAway;

package/dist/programs/helpers/fadeaway/logic.js

@@ -0,0 +1,69 @@
+import { createProgram } from "../../../util";
+const vertexShaderSource = `#version 300 es
+precision highp float; 
+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 + vec2(0.5);
+}
+`;
+const fragmentShaderSource = `#version 300 es
+precision highp float;
+uniform float opacity;
+uniform sampler2D u_texture;
+in vec2 v_texCoord;
+out vec4 outColor;
+void main() {
+
+    vec4 color = texture(u_texture, v_texCoord);
+    if (color.a <= 0.2) {
+        outColor = vec4(0.0);
+        return;
+    }
+    outColor = vec4(color.rgb, color.a * opacity);
+}
+`;
+export default class FadeAwayProgram {
+    constructor(gl) {
+        this.gl = gl;
+        this.program = createProgram(gl, vertexShaderSource, fragmentShaderSource);
+        this.vao = gl.createVertexArray();
+        gl.bindVertexArray(this.vao);
+        this._buffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+            -1, -1,
+            1, -1,
+            -1, 1,
+            -1, 1,
+            1, -1,
+            1, 1,
+        ]), gl.STATIC_DRAW);
+        gl.enableVertexAttribArray(0);
+        gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this.uniforms = {
+            u_texture: gl.getUniformLocation(this.program, 'u_texture'),
+            opacity: gl.getUniformLocation(this.program, 'opacity')
+        };
+    }
+    draw(texture, opacity) {
+        const { gl, vao, uniforms, program } = this;
+        gl.useProgram(program);
+        gl.bindVertexArray(vao);
+        gl.uniform1f(uniforms.opacity, opacity);
+        gl.uniform1i(uniforms.u_texture, 0);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.drawArrays(gl.TRIANGLES, 0, 6);
+        gl.bindVertexArray(null);
+    }
+    free() {
+        const { gl, vao, _buffer, program } = this;
+        gl.deleteVertexArray(vao);
+        gl.deleteProgram(program);
+        gl.deleteBuffer(_buffer);
+    }
+}