@pirireis/webglobeplugins 0.9.8 → 0.9.9

package/dist/programs/float2legendwithratio/logic.js

@@ -1,171 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../../util");
-class default_1 {
-    constructor(gl) {
-        this.gl = gl;
-        // console.log("Float2LegendWithRatioProgram gl:", gl);
-        this._width = 1;
-        this._height = 1;
-        this._blendRatio = 0.0;
-        this.programWrapper = this._createProgramWrapper();
-    }
-    _createProgramWrapper() {
-        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 + 0.5;
-            v_texcoord.y = 1.0 - v_texcoord.y;
-        }
-        `;
-        const fragmentShaderSource = `#version 300 es
-        precision highp float;
-
-        in vec2 v_texcoord;
-        uniform sampler2D u_float_texture0;
-        uniform sampler2D u_float_texture1;
-        uniform sampler2D u_color_texture;
-        
-        layout(std140) uniform HeatParametersBlock {
-            vec2 u_color_ramp_range; // x is min, y is range ( max - min)
-            vec2 u_min_max;
-            float u_escape_value;
-            float u_blend_ratio;
-        };
-
-        out vec4 outColor;
-
-        void main() {
-            if ( u_blend_ratio < 0.0) {
-                outColor = vec4(0.0, 0.0, 0.0, 0.0);
-                return;
-            }
-            float f0 = texture(u_float_texture0, v_texcoord).r;
-            float f1 = texture(u_float_texture1, v_texcoord).r;
-            // outColor = vec4(
-
-            if (f0 == u_escape_value || f1 == u_escape_value) {   
-                outColor = vec4(0.0, 0.0, 0.0, 0.0);
-                return;
-            }
-            float x  = mix(f0, f1, u_blend_ratio);
-            if ( x < u_min_max.x || x > u_min_max.y) {
-                outColor = vec4(0.0, 0.0, 0.0, 0.0);
-                return;    
-            }
-            x = (x - u_color_ramp_range.x) / u_color_ramp_range.y;            
-            outColor = texture(u_color_texture, vec2(x, 0.5));
-        }
-        `;
-        const gl = this.gl;
-        const program = (0, util_1.createProgram)(gl, vertexShaderSource, fragmentShaderSource);
-        const vao = gl.createVertexArray();
-        gl.bindVertexArray(vao);
-        const buffer = gl.createBuffer();
-        this._buffer = buffer;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
-            -1, -1,
-            1, -1,
-            1, 1,
-            -1, 1
-        ]), gl.STATIC_DRAW);
-        const positionLocation = gl.getAttribLocation(program, "a_position");
-        gl.enableVertexAttribArray(positionLocation);
-        gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0);
-        gl.bindVertexArray(null);
-        this.heatParametersBlockBindingPoint = 0;
-        const heatParametersBlockIndex = gl.getUniformBlockIndex(program, "HeatParametersBlock");
-        gl.uniformBlockBinding(program, heatParametersBlockIndex, this.heatParametersBlockBindingPoint);
-        return {
-            program,
-            vao,
-            u_float_texture0: gl.getUniformLocation(program, "u_float_texture0"),
-            u_float_texture1: gl.getUniformLocation(program, "u_float_texture1"),
-            u_color_texture: gl.getUniformLocation(program, "u_color_texture"),
-            u_blend_ratio: gl.getUniformLocation(program, "u_blend_ratio"),
-            u_color_ramp_range: gl.getUniformLocation(program, "u_color_ramp_range"),
-            u_min_max: gl.getUniformLocation(program, "u_min_max"),
-            u_escape_value: gl.getUniformLocation(program, "u_escape_value")
-        };
-    }
-    getUniformBlockManager() {
-        return new HeatParametersBlockManager(this.gl);
-    }
-    draw(texture0, texture1, colorRampTexture, heatParametersBlockManager) {
-        const { gl, programWrapper } = this;
-        const { program, u_float_texture0, u_float_texture1, u_color_texture } = programWrapper;
-        gl.useProgram(program);
-        gl.bindVertexArray(programWrapper.vao);
-        gl.activeTexture(gl.TEXTURE1);
-        gl.bindTexture(gl.TEXTURE_2D, texture1);
-        gl.uniform1i(u_float_texture1, 1);
-        gl.activeTexture(gl.TEXTURE2);
-        gl.bindTexture(gl.TEXTURE_2D, colorRampTexture);
-        gl.uniform1i(u_color_texture, 2);
-        gl.activeTexture(gl.TEXTURE0);
-        gl.bindTexture(gl.TEXTURE_2D, texture0);
-        gl.uniform1i(u_float_texture0, 0);
-        heatParametersBlockManager.bind();
-        // clear output texture
-        gl.clearColor(0, 0, 0, 0);
-        gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
-        gl.bindVertexArray(null);
-        heatParametersBlockManager.unbind();
-    }
-    free() {
-        const gl = this.gl;
-        gl.deleteBuffer(this._buffer);
-        gl.deleteProgram(this.programWrapper.program);
-        gl.deleteVertexArray(this.programWrapper.vao);
-    }
-}
-exports.default = default_1;
-class HeatParametersBlockManager {
-    constructor(gl) {
-        this.gl = gl;
-        this.buffer = gl.createBuffer();
-        gl.bindBuffer(gl.UNIFORM_BUFFER, this.buffer);
-        gl.bufferData(gl.UNIFORM_BUFFER, 24, gl.DYNAMIC_DRAW);
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-    /*
-    * @param {Array<number>} color_ramp_range  [minValue,( maxValue - minValue)]
-    * @param {Array<number>} min_max [minEdge, maxEdge]
-    * @param {number} escape_value // value that will be ignored
-    * @param {number} blend_ratio // ratio of blending between two textures
-    * */
-    update({ color_ramp_range = null, min_max = null, escape_value = null, blend_ratio = null }) {
-        const { gl, buffer } = this;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
-        if (color_ramp_range) {
-            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array(color_ramp_range));
-        }
-        if (min_max) {
-            gl.bufferSubData(gl.UNIFORM_BUFFER, 8, new Float32Array(min_max));
-        }
-        if (escape_value) {
-            gl.bufferSubData(gl.UNIFORM_BUFFER, 16, new Float32Array([escape_value]));
-        }
-        if (blend_ratio) {
-            gl.bufferSubData(gl.UNIFORM_BUFFER, 20, new Float32Array([blend_ratio]));
-        }
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-    bind() {
-        const { gl, buffer } = this;
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.heatParametersBlockBindingPoint, buffer);
-    }
-    free() {
-        this.gl.deleteBuffer(this.buffer);
-    }
-    unbind() {
-        const { gl } = this;
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.heatParametersBlockBindingPoint, null);
-    }
-}

package/dist/programs/float2legendwithratio/object.js

@@ -1,110 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const logic_1 = __importDefault(require("./logic"));
-const programcache_1 = require("../programcache");
-// Uniform Buffer Objects use this 
-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 = programcache_1.glProgramCache.getProgram(gl, logic_1.default);
-        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);
-        programcache_1.glProgramCache.releaseProgram(this.gl, logic_1.default);
-        this.heatParametersBlockManager.free();
-    }
-}
-exports.default = DataObject;

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

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const programcache_1 = require("../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) => programcache_1.noRegisterGlobeProgramCache.getProgram(globe, IsGlobeMoved),
-    release: (globe) => programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, IsGlobeMoved)
-});

package/dist/programs/globeshell/index.js

@@ -1,8 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlobeShellWiggle = void 0;
-const wiggle_1 = __importDefault(require("./globeshell/wiggle"));
-exports.GlobeShellWiggle = wiggle_1.default;

package/dist/programs/globeshell/noise/noises.js

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

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

@@ -1,8 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlobeShellWiggle = void 0;
-const object_1 = __importDefault(require("./object"));
-exports.GlobeShellWiggle = object_1.default;

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

@@ -1,345 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../../../util");
-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 = (0, util_1.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 };
-    }
-}
-exports.default = Logic;
-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);
-    }
-}