@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/programs/arrowfield/logic.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../../util");
+var programcache_1 = require("../programcache");
+var totems_1 = require("../totems");
+var arrowVertexShader = "#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\nuniform sampler2D rotation; // rotation of arrow\n\nout vec4 v_color;\n\nlayout(std140) uniform CameraBlock {\n    mat4 u_view;\n    mat4 u_projection;\n    vec3 u_translate;\n    bool u_is3D;\n    vec2 u_mapWH;\n    vec2 u_scrWH;\n    float u_zlevel;\n};\n\nlayout(std140) uniform ArrowBlock {\n    vec4 u_color;\n    vec2 u_bbox_offset_rad;\n    vec2 u_bbox_size_rad;\n    vec2 u_resolution;\n    float u_length_ratio;\n    float u_width_ratio;\n    float u_height;\n    float u_no_data_value;\n};\n\nvec2 f_texCoord(){\n    float fID = float(gl_InstanceID);\n    float x = mod( fID, u_resolution.x ) / ( u_resolution.x - 1.0);\n    float y = 1.0 - floor( fID / u_resolution.x ) / ( u_resolution.y - 1.0);\n    return vec2(x, y);\n}\n\nvec2 f_radCoord(vec2 texCoord){\n    float x = (texCoord.x * u_bbox_size_rad.x ) + u_bbox_offset_rad.x;\n    float y = (texCoord.y * u_bbox_size_rad.y ) + u_bbox_offset_rad.y;\n    return vec2(x, y);\n}\n\nvec3 f_onSphere(vec2 radCoord){\n    float x = sin(radCoord.y) * cos(radCoord.x);\n    float y = sin(radCoord.y) * sin(radCoord.x);\n    float z = cos(radCoord.y);\n    return vec3(x, y, z) * (R + u_height);\n}\n\n\nvec2 f_onFlat(vec2 radCoord){\n    float mercX = radCoord.x * POLE_BY_PI;\n    float mercY = log(tan(HALF_PI - radCoord.y * 0.5)) * POLE_BY_PI;\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\nvoid main() {\n    // escape if no data\n    vec2 texCoord = f_texCoord();\n    vec2 geoCoord = vec2( texCoord.x , 1.0 - texCoord.y );\n\n\n    float angle = texture(rotation, texCoord).r;\n\n    if ( angle == u_no_data_value ) {\n        gl_Position = vec4(-2.0, -2.0, 0.0, 1.0);\n        return;\n    }\n    vec2 arrowLimb;\n    if (0.0 == mod(float(gl_VertexID), 2.0)) {\n        arrowLimb = vec2(0.0, 0.0);\n    } else if (gl_VertexID == 1) {\n        // tail\n        arrowLimb = vec2( cos(angle), sin(angle)) * u_length_ratio / (170.0 );\n    } else if (gl_VertexID == 3) {\n        // right wing\n        arrowLimb = vec2( cos(angle + 0.45), sin(angle + 0.45)) * u_width_ratio / (170.0 );\n    } else if (gl_VertexID == 5) {\n        // left wing\n        arrowLimb = vec2( cos(angle - 0.45), sin(angle - 0.45)) * u_width_ratio / (170.0 );\n    }\n\n\n    vec2 radCoord = f_radCoord(geoCoord + arrowLimb);\n    if ( u_is3D ) {\n        vec3 spherePos = f_onSphere(radCoord);\n        gl_Position = u_projection * u_view * vec4(spherePos - u_translate, 1.0);\n    } else {\n        vec2 flatPos = f_onFlat(radCoord);\n        gl_Position = u_projection * vec4(\n            flatPos.x * u_scrWH.x, \n            (1.0 - flatPos.y) * u_scrWH.y,\n            0.0, 1.0\n        );\n    }\n\n\n    v_color = u_color;\n    gl_PointSize = 4.0;\n}\n";
+var arrowFragmentShader = "#version 300 es\nprecision highp float;\nin vec4 v_color;\nout vec4 outColor;\n\nvoid main() {\n    outColor = v_color;\n}\n";
+var ArrowFieldLogic = /** @class */ (function () {
+    function ArrowFieldLogic() {
+        this.gl = null;
+        this.globe = null;
+        this.cameraUniformBlockTotem = null;
+        this.program = null;
+        this.cameraBlockBindingPoint = 0;
+        this.arrayBlockBindingPoint = 1;
+    }
+    ArrowFieldLogic.prototype.init = function (globe, gl) {
+        this.gl = gl;
+        this.globe = globe;
+        this.cameraUniformBlockTotem = programcache_1.globeProgramCache.getProgram(globe, totems_1.CameraUniformBlockTotem);
+        this.program = this._createProgram();
+    };
+    ArrowFieldLogic.prototype._createProgram = function () {
+        var gl = this.gl;
+        var program = (0, util_1.createProgram)(gl, arrowVertexShader, arrowFragmentShader);
+        var cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraBlock");
+        gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
+        var arrowBlockIndex = gl.getUniformBlockIndex(program, "ArrowBlock");
+        gl.uniformBlockBinding(program, arrowBlockIndex, this.arrayBlockBindingPoint);
+        this.textureLocations = {
+            rotationLocation: gl.getUniformLocation(program, "rotation"),
+        };
+        return program;
+    };
+    ArrowFieldLogic.prototype.getArrowBlockBufferManager = function () {
+        return new ArrowBlockBufferManager(this.gl, this.arrayBlockBindingPoint);
+    };
+    // initial load type is static. 
+    // after that, it is dynamic.
+    ArrowFieldLogic.prototype.getTextureManager = function (width, height) {
+        return new TextureManager(this.gl, width, height, this.textureLocations);
+    };
+    ArrowFieldLogic.prototype.draw = function (arrowBlockManager, textureManager, instanceCount) {
+        var _a = this, gl = _a.gl, cameraBlockBindingPoint = _a.cameraBlockBindingPoint, cameraUniformBlockTotem = _a.cameraUniformBlockTotem;
+        gl.useProgram(this.program);
+        arrowBlockManager.bind();
+        textureManager.activate();
+        cameraUniformBlockTotem.bind(cameraBlockBindingPoint);
+        gl.drawArraysInstanced(gl.LINES, 0, 6, instanceCount);
+        // gl.drawArraysInstanced(gl.POINTS, 0, 4, instanceCount);
+        cameraUniformBlockTotem.unbind(cameraBlockBindingPoint);
+        arrowBlockManager.unbind();
+    };
+    ArrowFieldLogic.prototype.free = function () {
+        var _a = this, gl = _a.gl, program = _a.program;
+        gl.deleteProgram(program);
+        programcache_1.globeProgramCache.releaseProgram(this.globe, totems_1.CameraUniformBlockTotem);
+    };
+    return ArrowFieldLogic;
+}());
+exports.default = ArrowFieldLogic;
+var ArrowBlockBufferManager = /** @class */ (function () {
+    function ArrowBlockBufferManager(gl, bindingPoint) {
+        this.gl = gl;
+        this.bindingPoint = bindingPoint;
+        this.ubo = gl.createBuffer();
+        gl.bindBuffer(gl.UNIFORM_BUFFER, this.ubo);
+        // 4 + 2+ 2 + 2 + 1 +1 +1 +1+1= 15 ~= 16
+        gl.bufferData(gl.UNIFORM_BUFFER, 56, gl.DYNAMIC_DRAW);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+    ArrowBlockBufferManager.prototype.update = function (_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.color, color = _c === void 0 ? null : _c, _d = _b.bboxOffsetRad, bboxOffsetRad = _d === void 0 ? null : _d, _e = _b.bboxSizeRad, bboxSizeRad = _e === void 0 ? null : _e, _f = _b.resolution, resolution = _f === void 0 ? null : _f, _g = _b.tailLengthRatio, tailLengthRatio = _g === void 0 ? null : _g, _h = _b.wingLengthRatio, wingLengthRatio = _h === void 0 ? null : _h, _j = _b.height, height = _j === void 0 ? null : _j, _k = _b.opacity, opacity = _k === void 0 ? null : _k, _l = _b.noDataValue, noDataValue = _l === void 0 ? null : _l;
+        var _m = this, gl = _m.gl, ubo = _m.ubo;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        if (color !== null)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array(color));
+        if (opacity !== null)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 12, new Float32Array([opacity]));
+        if (bboxOffsetRad !== null)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 16, new Float32Array(bboxOffsetRad));
+        if (bboxSizeRad !== null)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 24, new Float32Array(bboxSizeRad));
+        if (resolution !== null)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 32, new Float32Array(resolution));
+        if (tailLengthRatio !== null)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 40, new Float32Array([tailLengthRatio]));
+        if (wingLengthRatio !== null)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 44, new Float32Array([wingLengthRatio]));
+        if (height !== null)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 48, new Float32Array([height]));
+        if (noDataValue !== null)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 52, new Float32Array([noDataValue]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    ArrowBlockBufferManager.prototype.bind = function () {
+        var _a = this, gl = _a.gl, ubo = _a.ubo, bindingPoint = _a.bindingPoint;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, ubo);
+    };
+    ArrowBlockBufferManager.prototype.unbind = function () {
+        var _a = this, gl = _a.gl, bindingPoint = _a.bindingPoint;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, null);
+    };
+    ArrowBlockBufferManager.prototype.free = function () {
+        var _a = this, gl = _a.gl, ubo = _a.ubo;
+        gl.deleteBuffer(ubo);
+    };
+    return ArrowBlockBufferManager;
+}());
+var TextureManager = /** @class */ (function () {
+    function TextureManager(gl, width, height, _a) {
+        var rotationLocation = _a.rotationLocation;
+        this.gl = gl;
+        this.width = width;
+        this.height = height;
+        this.rotationLocation = rotationLocation;
+        this.rotationTexture = this._createFloatTexture();
+    }
+    TextureManager.prototype._createFloatTexture = function () {
+        var _a = this, gl = _a.gl, width = _a.width, height = _a.height;
+        var texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.R32F, width, height, 0, gl.RED, gl.FLOAT, null);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        return texture;
+    };
+    TextureManager.prototype.setData = function (rotation) {
+        var _a = this, gl = _a.gl, rotationTexture = _a.rotationTexture, width = _a.width, height = _a.height;
+        // gl flip y axis
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+        gl.bindTexture(gl.TEXTURE_2D, rotationTexture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.R32F, width, height, 0, gl.RED, gl.FLOAT, rotation);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+    };
+    TextureManager.prototype.activate = function () {
+        var _a = this, gl = _a.gl, rotationTexture = _a.rotationTexture;
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, rotationTexture);
+        gl.uniform1i(this.rotationLocation, 0);
+    };
+    TextureManager.prototype.free = function () {
+        var _a = this, gl = _a.gl, rotationTexture = _a.rotationTexture;
+        gl.deleteTexture(rotationTexture);
+    };
+    return TextureManager;
+}());

package/programs/arrowfield/object.js

@@ -0,0 +1,68 @@
+"use strict";
+// this contains vao, drawCount, ArrowBufferBlock, vao,
+// how to, where to set instanced parameters
+// the vectorfield buffer should be managed outside, since it can be static or dynamic.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var logic_1 = __importDefault(require("./logic"));
+var programcache_1 = require("../programcache");
+var util_1 = require("../util");
+var ArrowField = /** @class */ (function () {
+    function ArrowField(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.opacity, opacity = _h === void 0 ? 1 : _h, _j = _b.color, color = _j === void 0 ? [0.04, 0.2, 0.8] : _j, _k = _b.targetWidth, targetWidth = _k === void 0 ? 100 : _k, _l = _b.targetHeight, targetHeight = _l === void 0 ? 100 : _l, _m = _b.dataWidth, dataWidth = _m === void 0 ? null : _m, _o = _b.dataHeight, dataHeight = _o === void 0 ? null : _o, _p = _b.tailLengthRatio, tailLengthRatio = _p === void 0 ? 1 : _p, _q = _b.wingLengthRatio, wingLengthRatio = _q === void 0 ? 0.5 : _q, _r = _b.noDataValue, noDataValue = _r === void 0 ? null : _r;
+        this.gl = gl;
+        this.globe = globe;
+        this.program = programcache_1.globeProgramCache.getProgram(globe, logic_1.default);
+        this.arrowBlockManager = this.program.getArrowBlockBufferManager();
+        this.instanceCount = targetWidth * targetHeight;
+        this.arrowBlockManager.update({ resolution: [targetWidth, targetHeight] });
+        this.textureManager = this.program.getTextureManager(dataWidth, dataHeight);
+        this.setBBox({ minLon: minLon, maxLon: maxLon, minLat: minLat, maxLat: maxLat });
+        this.update({ height: height, opacity: opacity, color: color, tailLengthRatio: tailLengthRatio, wingLengthRatio: wingLengthRatio, noDataValue: noDataValue });
+    }
+    ArrowField.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 };
+        var _g = (0, util_1.longlatbbox2normalbbox)(this.bbox), bboxSizeRad = _g.bboxSizeRad, bboxOffsetRad = _g.bboxOffsetRad;
+        this.arrowBlockManager.update({ bboxSizeRad: bboxSizeRad, bboxOffsetRad: bboxOffsetRad });
+        this.globe.DrawRender();
+    };
+    ArrowField.prototype.update = function (_a) {
+        var _b = _a === void 0 ? {} : _a, height = _b.height, opacity = _b.opacity, color = _b.color, resolution = _b.resolution, tailLengthRatio = _b.tailLengthRatio, wingLengthRatio = _b.wingLengthRatio, noDataValue = _b.noDataValue;
+        if (resolution) {
+            this.instanceCount = resolution[0] * resolution[1];
+        }
+        this.arrowBlockManager.update({
+            color: color,
+            resolution: resolution,
+            height: height,
+            opacity: opacity,
+            tailLengthRatio: tailLengthRatio,
+            wingLengthRatio: wingLengthRatio,
+            noDataValue: noDataValue,
+        });
+        this.globe.DrawRender();
+    };
+    ArrowField.prototype.setTargetResolution = function (width, height) {
+        this.instanceCount = width * height;
+        this.arrowBlockManager.update({ resolution: [width, height] });
+        this.globe.DrawRender();
+    };
+    ArrowField.prototype.draw = function () {
+        var _a = this, program = _a.program, arrowBlockManager = _a.arrowBlockManager, textureManager = _a.textureManager, instanceCount = _a.instanceCount;
+        program.draw(arrowBlockManager, textureManager, instanceCount);
+    };
+    ArrowField.prototype.setData = function (rotation) {
+        this.textureManager.setData(rotation);
+        this.globe.DrawRender();
+    };
+    ArrowField.prototype.free = function () {
+        this.arrowBlockManager.free();
+        this.textureManager.free();
+        programcache_1.globeProgramCache.releaseProgram(this.gl, logic_1.default);
+    };
+    return ArrowField;
+}());
+exports.default = ArrowField;

package/programs/data2legend/density-to-legend.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.densityToLegendProgramCache = void 0;
+var util_1 = require("../../util/");
+var programcache_1 = require("../programcache");
+var vs = "#version 300 es\nprecision highp float;\n\nuniform sampler2D u_density_texture;\nin vec2 a_position;\n\nout vec2 v_texcoord;\n\nvoid main() {\n    gl_Position = vec4(a_position, 0.0, 1.0);\n    v_texcoord = a_position * 0.5 + 0.5;\n}";
+var fs = "#version 300 es\nprecision highp float;\n\nuniform sampler2D u_legend_texture;\nuniform sampler2D u_density_texture;\n\nuniform float u_opacity;\nin vec2 v_texcoord;\nout vec4 fragColor;\n\nvoid main() {\n    float density = texture(u_density_texture, v_texcoord).r;\n    fragColor = texture(u_legend_texture, vec2(density, 0.5));\n    fragColor.a *= u_opacity * sqrt(density);\n}";
+var DensityToLegendProgram = /** @class */ (function () {
+    function DensityToLegendProgram(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = (0, util_1.createProgram)(globe.gl, vs, fs);
+        var _a = this, gl = _a.gl, program = _a.program;
+        this.uniforms = {
+            densityTexture: gl.getUniformLocation(program, "u_density_texture"),
+            legendTexture: gl.getUniformLocation(program, "u_legend_texture"),
+            opacity: gl.getUniformLocation(program, "u_opacity"),
+        };
+        { // assign attribute locations
+            gl.bindAttribLocation(program, 0, "a_position");
+        }
+        {
+            this.vao = gl.createVertexArray();
+            var a_positionLocation = gl.getAttribLocation(program, "a_position");
+            gl.bindVertexArray(this.vao);
+            var buffer = gl.createBuffer();
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+                -1, -1,
+                1, -1,
+                1, 1,
+                -1, 1,
+            ]), gl.STATIC_DRAW);
+            gl.enableVertexAttribArray(a_positionLocation);
+            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+            gl.bindVertexArray(null);
+            // gl.bindBuffer(gl.ARRAY_BUFFER, null);
+            this._buffer = buffer;
+        }
+        {
+            this._lastOpacity = 1;
+            var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(this.uniforms.opacity, this._lastOpacity);
+            gl.useProgram(currentProgram);
+        }
+    }
+    DensityToLegendProgram.prototype.draw = function (densityTexture, legendTexture, opacity) {
+        var _a = this, gl = _a.gl, program = _a.program, uniforms = _a.uniforms;
+        gl.useProgram(program);
+        gl.bindVertexArray(this.vao);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, legendTexture);
+        gl.uniform1i(uniforms.legendTexture, 1);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, densityTexture);
+        gl.uniform1i(uniforms.densityTexture, 0);
+        if (this._lastOpacity !== opacity) {
+            gl.uniform1f(uniforms.opacity, opacity);
+            this._lastOpacity = opacity;
+        }
+        gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
+        gl.bindVertexArray(null);
+    };
+    DensityToLegendProgram.prototype.free = function () {
+        var gl = this.gl;
+        gl.deleteVertexArray(this.vao);
+        gl.deleteBuffer(this._buffer);
+        gl.deleteProgram(this.program);
+    };
+    return DensityToLegendProgram;
+}());
+var densityToLegendProgramCache = {
+    get: function (globe) { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, DensityToLegendProgram); },
+    release: function (globe) { return programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, DensityToLegendProgram); }
+};
+exports.densityToLegendProgramCache = densityToLegendProgramCache;

package/programs/data2legend/point-to-density-texture.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pointToDensityTextureCache = void 0;
+var util_1 = require("../../util/");
+var programcache_1 = require("../programcache");
+var camerauniformblock_1 = require("../totems/camerauniformblock");
+var geometrytransformations_1 = require("../../util/shaderfunctions/geometrytransformations");
+var vs = "#version 300 es\nprecision highp float;\n\n".concat(camerauniformblock_1.CameraUniformBlockString, "\n").concat(geometrytransformations_1.mercatorXYToGLPosition, "\n").concat(geometrytransformations_1.cartesian3DToGLPosition, "\n\nin vec3 position;\nuniform float pointSize;\n\nvoid main() {\n    if (is3D) {\n        gl_Position = cartesian3DToGLPosition(position);\n    } else {\n        gl_Position = mercatorXYToGLPosition(position.xy);\n    }\n    gl_PointSize = pointSize;\n}\n");
+var fs = "#version 300 es\nprecision highp float;\nout vec4 fragColor;\n\nvoid main() {\n    float r = length(gl_PointCoord - 0.5) * 2.0;\n    if (r > 1.0) discard;\n    // float density = smoothstep(0.1, 1.0, 1.0 - r);\n    fragColor = vec4((15.0/16.0)*sqrt(1.0-sqrt(r)));\n}";
+var PointHeatmapProgram = /** @class */ (function () {
+    function PointHeatmapProgram(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._isFreed = false;
+        this.program = (0, util_1.createProgram)(globe.gl, vs, fs);
+        var _a = this, gl = _a.gl, program = _a.program;
+        this.uniforms = {
+            pointSize: gl.getUniformLocation(this.program, "pointSize"),
+        };
+        { // assign attribute locations 
+            gl.bindAttribLocation(program, 0, "position");
+        }
+        { // arrange camera uniform block
+            this.cameraBlockBingingPoint = 0;
+            this.cameraBlockTotem = camerauniformblock_1.CameraUniformBlockTotemCache.get(globe);
+            var cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+            gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBingingPoint);
+        }
+        { // last values
+            this._lastPointSize = 0;
+            var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(this.uniforms.pointSize, this._lastPointSize);
+            gl.useProgram(currentProgram);
+        }
+    }
+    PointHeatmapProgram.prototype.createVAO = function (positionBuffer, vectorSize) {
+        var gl = this.gl;
+        var vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
+        gl.enableVertexAttribArray(0);
+        gl.vertexAttribPointer(0, vectorSize, gl.FLOAT, false, 0, 0);
+        gl.bindVertexArray(null);
+        return vao;
+    };
+    PointHeatmapProgram.prototype.draw = function (vao, length, pointSize) {
+        if (pointSize === void 0) { pointSize = 5.0; }
+        var gl = this.gl;
+        gl.useProgram(this.program);
+        if (pointSize !== this._lastPointSize) {
+            gl.uniform1f(this.uniforms.pointSize, pointSize);
+            this._lastPointSize = pointSize;
+        }
+        gl.bindVertexArray(vao);
+        this.cameraBlockTotem.bind(this.cameraBlockBingingPoint);
+        gl.drawArrays(gl.POINTS, 0, length);
+        this.cameraBlockTotem.unbind(this.cameraBlockBingingPoint);
+        gl.bindVertexArray(null);
+    };
+    PointHeatmapProgram.prototype.free = function () {
+        if (this._isFreed)
+            return;
+        var _a = this, gl = _a.gl, globe = _a.globe;
+        camerauniformblock_1.CameraUniformBlockTotemCache.release(globe);
+        gl.deleteProgram(this.program);
+        this._isFreed = true;
+    };
+    return PointHeatmapProgram;
+}());
+var pointToDensityTextureCache = {
+    get: function (globe) { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, PointHeatmapProgram); },
+    release: function (globe) { return programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, PointHeatmapProgram); }
+};
+exports.pointToDensityTextureCache = pointToDensityTextureCache;

package/programs/float2legendwithratio/index.js

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

package/programs/float2legendwithratio/logic.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../../util");
+var default_1 = /** @class */ (function () {
+    function default_1(gl) {
+        this.gl = gl;
+        // console.log("Float2LegendWithRatioProgram gl:", gl);
+        this._width = 1;
+        this._height = 1;
+        this._blendRatio = 0.0;
+        this.programWrapper = this._createProgramWrapper();
+    }
+    default_1.prototype._createProgramWrapper = function () {
+        var vertexShaderSource = "#version 300 es\n        precision highp float;\n\n        in vec2 a_position;\n        out vec2 v_texcoord;\n         \n        void main() {\n            gl_Position = vec4(a_position, 0.0, 1.0);\n            v_texcoord = a_position * 0.5 + 0.5;\n            v_texcoord.y = 1.0 - v_texcoord.y;\n        }\n        ";
+        var fragmentShaderSource = "#version 300 es\n        precision highp float;\n\n        in vec2 v_texcoord;\n        uniform sampler2D u_float_texture0;\n        uniform sampler2D u_float_texture1;\n        uniform sampler2D u_color_texture;\n        \n        layout(std140) uniform HeatParametersBlock {\n            vec2 u_color_ramp_range; // x is min, y is range ( max - min)\n            vec2 u_min_max;\n            float u_escape_value;\n            float u_blend_ratio;\n        };\n\n        out vec4 outColor;\n\n        void main() {\n            if ( u_blend_ratio < 0.0) {\n                outColor = vec4(0.0, 0.0, 0.0, 0.0);\n                return;\n            }\n            float f0 = texture(u_float_texture0, v_texcoord).r;\n            float f1 = texture(u_float_texture1, v_texcoord).r;\n            // outColor = vec4(\n\n            if (f0 == u_escape_value || f1 == u_escape_value) {   \n                outColor = vec4(0.0, 0.0, 0.0, 0.0);\n                return;\n            }\n            float x  = mix(f0, f1, u_blend_ratio);\n            if ( x < u_min_max.x || x > u_min_max.y) {\n                outColor = vec4(0.0, 0.0, 0.0, 0.0);\n                return;    \n            }\n            x = (x - u_color_ramp_range.x) / u_color_ramp_range.y;            \n            outColor = texture(u_color_texture, vec2(x, 0.5));\n        }\n        ";
+        var gl = this.gl;
+        var program = (0, util_1.createProgram)(gl, vertexShaderSource, fragmentShaderSource);
+        var vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        var 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);
+        var positionLocation = gl.getAttribLocation(program, "a_position");
+        gl.enableVertexAttribArray(positionLocation);
+        gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0);
+        gl.bindVertexArray(null);
+        this.heatParametersBlockBindingPoint = 0;
+        var heatParametersBlockIndex = gl.getUniformBlockIndex(program, "HeatParametersBlock");
+        gl.uniformBlockBinding(program, heatParametersBlockIndex, this.heatParametersBlockBindingPoint);
+        return {
+            program: program,
+            vao: 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")
+        };
+    };
+    default_1.prototype.getUniformBlockManager = function () {
+        return new HeatParametersBlockManager(this.gl);
+    };
+    default_1.prototype.draw = function (texture0, texture1, colorRampTexture, heatParametersBlockManager) {
+        var _a = this, gl = _a.gl, programWrapper = _a.programWrapper;
+        var program = programWrapper.program, u_float_texture0 = programWrapper.u_float_texture0, u_float_texture1 = programWrapper.u_float_texture1, u_color_texture = programWrapper.u_color_texture;
+        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();
+    };
+    default_1.prototype.free = function () {
+        var gl = this.gl;
+        gl.deleteBuffer(this._buffer);
+        gl.deleteProgram(this.programWrapper.program);
+        gl.deleteVertexArray(this.programWrapper.vao);
+    };
+    return default_1;
+}());
+exports.default = default_1;
+var HeatParametersBlockManager = /** @class */ (function () {
+    function HeatParametersBlockManager(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
+    * */
+    HeatParametersBlockManager.prototype.update = function (_a) {
+        var _b = _a.color_ramp_range, color_ramp_range = _b === void 0 ? null : _b, _c = _a.min_max, min_max = _c === void 0 ? null : _c, _d = _a.escape_value, escape_value = _d === void 0 ? null : _d, _e = _a.blend_ratio, blend_ratio = _e === void 0 ? null : _e;
+        var _f = this, gl = _f.gl, buffer = _f.buffer;
+        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);
+    };
+    HeatParametersBlockManager.prototype.bind = function () {
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.heatParametersBlockBindingPoint, buffer);
+    };
+    HeatParametersBlockManager.prototype.free = function () {
+        this.gl.deleteBuffer(this.buffer);
+    };
+    HeatParametersBlockManager.prototype.unbind = function () {
+        var gl = this.gl;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.heatParametersBlockBindingPoint, null);
+    };
+    return HeatParametersBlockManager;
+}());

package/programs/float2legendwithratio/object.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var logic_1 = __importDefault(require("./logic"));
+var programcache_1 = require("../programcache");
+// Uniform Buffer Objects use this 
+var DataObject = /** @class */ (function () {
+    function DataObject(gl, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.width, width = _c === void 0 ? 1 : _c, _d = _b.height, height = _d === void 0 ? 1 : _d, _e = _b.texture0, texture0 = _e === void 0 ? null : _e, _f = _b.texture1, texture1 = _f === void 0 ? null : _f, _g = _b.colorRampTexture, colorRampTexture = _g === void 0 ? null : _g, _h = _b.colorRampRange, colorRampRange = _h === void 0 ? null : _h, _j = _b.escapeValue, escapeValue = _j === void 0 ? 99999 : _j, _k = _b.blendRatio, blendRatio = _k === void 0 ? 0.0 : _k, _l = _b.minMaxEdges, minMaxEdges = _l === void 0 ? null : _l;
+        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
+        });
+    }
+    DataObject.prototype._bindBlock = function () {
+        var gl = this.gl;
+        var program = this.programlogic.programWrapper.program;
+        gl.uniformBlockBinding(program, gl.getUniformBlockIndex(program, 'Block'), 0);
+    };
+    DataObject.prototype._createColorRampTexture = function () {
+        var gl = this.gl;
+        var 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;
+    };
+    DataObject.prototype.setBlendRatio = function (ratio) {
+        if (ratio < 0 || ratio > 1) {
+            console.warn('Invalid blend ratio');
+            return;
+        }
+        this.heatParametersBlockManager.update({ blend_ratio: ratio });
+    };
+    DataObject.prototype.setEscapeValue = function (value) {
+        this.heatParametersBlockManager.update({ escape_value: value });
+    };
+    DataObject.prototype.setTexture0 = function (texture) {
+        this.texture0 = texture;
+    };
+    DataObject.prototype.setTexture1 = function (texture) {
+        this.texture1 = texture;
+    };
+    DataObject.prototype.setColorRampTexture = function (texture) {
+        this.colorRampTexture = texture;
+    };
+    DataObject.prototype.setDataWidthHeight = function (width, height) {
+        this.width = width;
+        this.height = height;
+    };
+    DataObject.prototype.setFloatTextureData = function (data0, data1, width, height, yFlip) {
+        if (yFlip === void 0) { yFlip = false; }
+        var _a = this, texture0 = _a.texture0, texture1 = _a.texture1, gl = _a.gl;
+        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);
+    };
+    DataObject.prototype.discard = function () {
+        this.heatParametersBlockManager.update({ blend_ratio: -1 });
+    };
+    DataObject.prototype.setColorRampTextureData = function (data, size) {
+        var _a = this, gl = _a.gl, colorRampTexture = _a.colorRampTexture;
+        gl.bindTexture(gl.TEXTURE_2D, colorRampTexture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
+    };
+    DataObject.prototype.setColorRampRange = function (min, max) {
+        if (min > max) {
+            console.warn('Invalid min max values');
+            return;
+        }
+        var range = max - min;
+        this.heatParametersBlockManager.update({ color_ramp_range: new Float32Array([min, range]) });
+    };
+    DataObject.prototype.setMinMaxEdges = function (min, max) {
+        if (min)
+            this.minMaxEdges[0] = min;
+        if (max)
+            this.minMaxEdges[1] = max;
+        this.heatParametersBlockManager.update({ min_max: this.minMaxEdges });
+    };
+    DataObject.prototype.draw = function () {
+        this.programlogic.draw(this.texture0, this.texture1, this.colorRampTexture, this.heatParametersBlockManager);
+    };
+    DataObject.prototype.free = function () {
+        var _a = this, gl = _a.gl, texture0 = _a.texture0, texture1 = _a.texture1, colorRampTexture = _a.colorRampTexture;
+        gl.deleteTexture(texture0);
+        gl.deleteTexture(texture1);
+        gl.deleteTexture(colorRampTexture);
+        programcache_1.glProgramCache.releaseProgram(this.gl, logic_1.default);
+        this.heatParametersBlockManager.free();
+    };
+    return DataObject;
+}());
+exports.default = DataObject;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var programcache_1 = require("../programcache");
+var IsGlobeMoved = /** @class */ (function () {
+    function IsGlobeMoved(globe) {
+        this.globe = globe;
+        this._lastLOD = globe.api_GetCurrentLODWithDecimal();
+    }
+    IsGlobeMoved.prototype.isMoved = function () {
+        var globe = this.globe;
+        if (globe.api_IsScreenMoving() || this._lastLOD != globe.api_GetCurrentLODWithDecimal()) {
+            this._lastLOD = globe.api_GetCurrentLODWithDecimal();
+            return true;
+        }
+        return false;
+    };
+    return IsGlobeMoved;
+}());
+var IsGlobeMovedCache = Object.freeze({
+    get: function (globe) { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, IsGlobeMoved); },
+    release: function (globe) { return programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, IsGlobeMoved); }
+});

package/programs/globeshell/index.js

@@ -0,0 +1,8 @@
+"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;
+var wiggle_1 = __importDefault(require("./globeshell/wiggle"));
+exports.GlobeShellWiggle = wiggle_1.default;

package/programs/globeshell/noise/noises.js

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