@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/util/jshelpers/timefilters.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instantDebounce = instantDebounce;
+// TODO: fix logic error in instantDebounce
+function instantDebounce(func, delay) {
+    var timeout = null;
+    var lastArgs = null;
+    var runAtEnd = false;
+    var timeoutMethod = function () {
+        setTimeout(function () {
+            if (runAtEnd) {
+                func.apply(void 0, lastArgs);
+                lastArgs = null;
+                // console.log("processed with delay")
+                runAtEnd = false;
+            }
+            timeout = null;
+        }, delay);
+    };
+    return function () {
+        if (timeout) {
+            lastArgs = arguments;
+            runAtEnd = true;
+            return;
+        }
+        else {
+            func.apply(void 0, args);
+            // console.log("processed instantly")
+            timeout = timeoutMethod();
+        }
+    };
+}

package/util/picking/fence.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fence = void 0;
+var fence = function (gl) { return new Promise(function (resolve, reject) {
+    // This will create a fence. If this follows a `readPixels()` call, then it
+    // will signal to WebGL that the read instruction should be asynchronous. 
+    // This means JS can continue to work on other tasks while the read instruction
+    // completes.
+    var sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
+    gl.flush();
+    // There are TWO possible ways to check on the status of a WebGLSync object.
+    // 1. This will check it using clientWaitSync()
+    var checkStatus_v1 = function () {
+        var status = gl.clientWaitSync(sync, 0, 0);
+        // There are four possible values for status:
+        // a. ALREADY_SIGNALED and CONDITION_SATISFIED (done)
+        // b. TIMEOUT_EXPIRED (check again later)
+        // c. WAIT_FAILED (there was an error)
+        if (status === gl.TIMEOUT_EXPIRED) {
+            setTimeout(checkStatus_v1, 1);
+        }
+        else if (status === gl.ALREADY_SIGNALED || status === gl.CONDITION_SATISFIED) {
+            gl.deleteSync(sync);
+            resolve();
+        }
+        else {
+            gl.deleteSync(sync);
+            reject(new Error('Fence did not resolve normally for some reason'));
+        }
+    };
+    // 2. This will check with getSyncParameter(s, gl.SYNC_STATUS)
+    var checkStatus_v2 = function () {
+        var status = gl.getSyncParameter(sync, gl.SYNC_STATUS);
+        // There are only two possible values for status: SIGNALED and UNSIGNALED
+        // Note that there is no `error` signal, so there is no reason to use `reject()` here
+        if (status === gl.SIGNALED) {
+            gl.deleteSync(sync);
+            resolve();
+        }
+        else {
+            setTimeout(checkStatus_v2, 1);
+        }
+    };
+    setTimeout(checkStatus_v2, 1);
+}); };
+exports.fence = fence;

package/util/picking/picker-displayer.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * add implicit texture display program for color
+ * add fence on query return and return id.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PickerDisplayer = void 0;
+var draw_texture_on_canvas_1 = require("../programs/draw-texture-on-canvas");
+var fence_1 = require("./fence");
+var ESCAPE_VALUE = -1;
+var PickerDisplayer = /** @class */ (function () {
+    function PickerDisplayer(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        var gl = this.gl;
+        this.colorTexture = gl.createTexture(); // bind to color attachment 0
+        this.indexTexture = gl.createTexture(); // bind to color attachment 1
+        this.fbo = gl.createFramebuffer();
+        this._pbo = undefined;
+        this._pboSize = 0;
+        this.resize();
+        this.displayer = draw_texture_on_canvas_1.textureOnCanvasProgramCache.get(this.gl);
+    }
+    PickerDisplayer.prototype.resize = function (width, height) {
+        if (width === void 0) { width = null; }
+        if (height === void 0) { height = null; }
+        if (width === null || height === null) {
+            width = this.globe.api_ScrW();
+            height = this.globe.api_ScrH();
+        }
+        var _a = this, gl = _a.gl, colorTexture = _a.colorTexture, indexTexture = _a.indexTexture;
+        gl.deleteTexture(colorTexture);
+        gl.deleteTexture(indexTexture);
+        var colorTextureNew = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, colorTextureNew);
+        gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, width, height);
+        var indexTextureNew = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, indexTextureNew);
+        // gl.texStorage2D(gl.TEXTURE_2D, 1, gl.R16I, width, height);
+        gl.texStorage2D(gl.TEXTURE_2D, 1, gl.R32I, width, height);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        this.colorTexture = colorTextureNew;
+        this.indexTexture = indexTextureNew;
+    };
+    PickerDisplayer.prototype.clearTextures = function () {
+        var _a = this, gl = _a.gl, colorTexture = _a.colorTexture, indexTexture = _a.indexTexture;
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, indexTexture);
+        gl.clearBufferiv(gl.COLOR, 1, new Int32Array([-1, -1, -1, -1]));
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, colorTexture);
+        gl.clearBufferfv(gl.COLOR, 0, new Float32Array([0, 0, 0, 0]));
+    };
+    // call before drawing the scene with gl picker shader
+    PickerDisplayer.prototype.bindFBO = function () {
+        var _a = this, gl = _a.gl, colorTexture = _a.colorTexture, indexTexture = _a.indexTexture, fbo = _a.fbo;
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, indexTexture);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, colorTexture);
+        { // bind framebuffer
+            gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this.colorTexture, 0);
+            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this.indexTexture, 0);
+            gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1]);
+        }
+    };
+    // call after drawing the scene with gl picker shader
+    PickerDisplayer.prototype.drawColorTexture = function () {
+        var colorTexture = this.colorTexture;
+        this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, null);
+        this.displayer.draw(colorTexture);
+    };
+    PickerDisplayer.prototype.pickXY = function (x, y, selectionPointFilling, callback) {
+        if (selectionPointFilling === void 0) { selectionPointFilling = 1; }
+        if (callback === void 0) { callback = function () { }; }
+        var size = Math.pow(1 + 2 * selectionPointFilling, 2);
+        this._pick(size, x - selectionPointFilling, y - selectionPointFilling, 1 + 2 * selectionPointFilling, 1 + 2 * selectionPointFilling, callback);
+    };
+    PickerDisplayer.prototype.pickBbox = function (left, top, right, bottom, callback) {
+        var size = (right - left) * (bottom - top) * 4;
+        this._pick(size, left, top, right - left, bottom - top, callback);
+    };
+    PickerDisplayer.prototype._pick = function (size, startX, startY, lengthX, lengthY, callback) {
+        var _this = this;
+        if (this._inProgress)
+            return false;
+        this._inProgress = true;
+        this._initHoldBuffer(size * 4);
+        var _a = this, gl = _a.gl, _pbo = _a._pbo;
+        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, _pbo);
+        this.bindFBO();
+        gl.readBuffer(gl.COLOR_ATTACHMENT1); // This is the attachment we want to read
+        gl.readPixels(// This will read the pixels to the buffer asynchronously
+        startX, startY, lengthX, lengthY, gl.RED_INTEGER, gl.INT, 0);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
+        (0, fence_1.fence)(this.gl).then(function () {
+            gl.bindBuffer(gl.PIXEL_PACK_BUFFER, _pbo);
+            // const data = new Int16Array(size);
+            var data = new Int32Array(size);
+            gl.getBufferSubData(gl.PIXEL_PACK_BUFFER, 0, data);
+            gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
+            var result = _this._pickFromBuffer(data, size);
+            callback(result);
+            // gl.deleteBuffer(pbo);
+            _this._inProgress = false;
+        });
+        return true;
+    };
+    PickerDisplayer.prototype._pickFromBuffer = function (array, size) {
+        var selectedObjects = new Set();
+        for (var i = 0; i < size; i += 1) {
+            var id = array[i];
+            if (id !== ESCAPE_VALUE) {
+                selectedObjects.add(id);
+            }
+        }
+        return selectedObjects;
+    };
+    PickerDisplayer.prototype._initHoldBuffer = function (size) {
+        if (this._pbo && this._pboSize >= size) {
+            return;
+        }
+        var gl = this.gl;
+        var pbo = gl.createBuffer();
+        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, pbo);
+        gl.bufferData(gl.PIXEL_PACK_BUFFER, size, gl.STREAM_READ);
+        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
+        this._pboSize = size;
+        if (this._pbo !== undefined) {
+            gl.deleteBuffer(this._pbo);
+        }
+        this._pbo = pbo;
+    };
+    PickerDisplayer.prototype.free = function () {
+        var _a = this, gl = _a.gl, colorTexture = _a.colorTexture, indexTexture = _a.indexTexture, fbo = _a.fbo;
+        gl.deleteTexture(colorTexture);
+        gl.deleteTexture(indexTexture);
+        gl.deleteFramebuffer(fbo);
+        draw_texture_on_canvas_1.textureOnCanvasProgramCache.release(this.gl);
+    };
+    return PickerDisplayer;
+}());
+exports.PickerDisplayer = PickerDisplayer;

package/util/programs/draw-texture-on-canvas.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textureOnCanvasProgramCache = void 0;
+var webglobjectbuilders_1 = require("../webglobjectbuilders");
+var programs_1 = require("../../programs");
+// import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../../programs/totems";
+var vs = "#version 300 es\nprecision highp float;\n\nin vec2 a_position;\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_texture;\nuniform float u_opacity;    \nin vec2 v_texcoord;\nout vec4 fragColor;\n\nvoid main() {\n    fragColor = texture(u_texture, v_texcoord);\n    fragColor.a *= u_opacity;\n}";
+var TextureOnCanvasProgram = /** @class */ (function () {
+    function TextureOnCanvasProgram(gl) {
+        this.gl = gl;
+        this.vao = this.gl.createVertexArray();
+        this.buffer = this.gl.createBuffer();
+        this.gl.bindVertexArray(this.vao);
+        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.buffer);
+        this.gl.bufferData(this.gl.ARRAY_BUFFER, new Float32Array([
+            -1, -1,
+            1, -1,
+            1, 1,
+            -1, 1
+        ]), this.gl.STATIC_DRAW);
+        this.gl.enableVertexAttribArray(0);
+        this.gl.vertexAttribPointer(0, 2, this.gl.FLOAT, false, 0, 0);
+        this.gl.bindVertexArray(null);
+        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
+        this.program = (0, webglobjectbuilders_1.createProgram)(this.gl, vs, fs);
+        {
+            var _a = this, gl_1 = _a.gl, program = _a.program;
+            this.uniforms = {
+                texture: gl_1.getUniformLocation(program, "u_texture"),
+                opacity: gl_1.getUniformLocation(program, "u_opacity"),
+            };
+        }
+        {
+            this._lastOpacity = 1.0;
+            var currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
+            this.gl.useProgram(this.program);
+            this.gl.uniform1f(this.uniforms.opacity, this._lastOpacity);
+            this.gl.useProgram(currentProgram);
+        }
+    }
+    TextureOnCanvasProgram.prototype.draw = function (texture, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.opacity, opacity = _c === void 0 ? 1.0 : _c;
+        var _d = this, gl = _d.gl, program = _d.program, uniforms = _d.uniforms, vao = _d.vao;
+        gl.useProgram(program);
+        gl.bindVertexArray(vao);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.uniform1i(uniforms.texture, 0);
+        if (this._lastOpacity !== opacity) {
+            gl.uniform1f(uniforms.opacity, opacity);
+            this._lastOpacity = opacity;
+        }
+        gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
+        gl.bindVertexArray(null);
+    };
+    TextureOnCanvasProgram.prototype.free = function () {
+        if (this._isFreed)
+            return;
+        this.gl.deleteVertexArray(this.vao);
+        this.gl.deleteBuffer(this.buffer);
+        this.gl.deleteProgram(this.program);
+        this._isFreed = true;
+    };
+    return TextureOnCanvasProgram;
+}());
+var textureOnCanvasProgramCache = Object.freeze({
+    get: function (gl) { return programs_1.glProgramCache.getProgram(gl, TextureOnCanvasProgram); },
+    release: function (gl) { return programs_1.glProgramCache.releaseProgram(gl, TextureOnCanvasProgram); }
+});
+exports.textureOnCanvasProgramCache = textureOnCanvasProgramCache;

package/util/programs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./shapesonglobe"), exports);

package/util/programs/shapesonglobe.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShapesOnGlobeProgram = void 0;
+var webglobjectbuilders_1 = require("../webglobjectbuilders");
+var camerauniformblock_1 = require("../../programs/totems/camerauniformblock");
+var __1 = require("..");
+/** TODO:
+ * 3d icin calistir
+ */
+var drawModeFunc = function (gl) {
+    return function (mode) {
+        return {
+            "point": gl.POINTS,
+            "line": gl.LINES,
+            "line_strip": gl.LINE_STRIP,
+            "line_loop": gl.LINE_LOOP,
+            "triangle": gl.TRIANGLES,
+            "triangle_strip": gl.TRIANGLE_STRIP,
+            "triangle_fan": gl.TRIANGLE_FAN
+        }[mode];
+    };
+};
+var ShapesOnGlobeProgram = /** @class */ (function () {
+    function ShapesOnGlobeProgram(gl, globe, drawMode) {
+        if (drawMode === void 0) { drawMode = 'point'; }
+        this.globe = globe;
+        this.gl = gl;
+        this._getDraw = drawModeFunc(gl);
+        this._drawMode = this._getDraw(drawMode);
+        this._is3D = true;
+        this._inBuffer = gl.createBuffer();
+        this._programWrapper = this._createProgramWrapper();
+        this._initUniforms();
+        this.setScreenWH();
+    }
+    ShapesOnGlobeProgram.prototype._initUniforms = function () {
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        this._getDrawMode = drawModeFunc(gl);
+        gl.useProgram(_programWrapper.program);
+        gl.uniform1f(_programWrapper.u_opacity, 1.0);
+        gl.uniform1f(_programWrapper.u_is3D, 1.0);
+        gl.uniform1f(_programWrapper.height, 0.0);
+        gl.uniform1f(_programWrapper.u_point_size, 1.0);
+        gl.useProgram(currentProgram);
+    };
+    ShapesOnGlobeProgram.prototype._createProgramWrapper = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe;
+        var vertexSource = "#version 300 es\n            precision highp float;\n            ".concat(camerauniformblock_1.CameraUniformBlockString, "\n\n            in vec2 a_position;\n            in vec4 a_color;\n\n\n            uniform bool u_is3D;\n            uniform float height; \n\n            uniform float u_point_size;\n\n            out vec4 v_color;\n\n            ") + __1.shaderfunctions.pixelXYToCartesian3DPoint + "\n            " + __1.shaderfunctions.pixelXYToCartesian2DPoint + "\n\n\n            void main() {\n                vec3 pos = vec3(a_position, height);\n                if(is3D){\n                    pos = pixelXYToCartesian3DPoint(pos);\n                    gl_Position = projection * view * vec4(pos - translate, 1.0);\n                } else {\n                    vec2 xy = pixelXYToCartesian2DPoint(pos.xy, translate.xy, mapWH, screenWH);\n                    gl_Position = projection * vec4(xy.x, xy.y, 0.0, 1.0);\n                }\n                gl_PointSize = u_point_size;\n                v_color = a_color;\n            }\n            ";
+        var fragmentSource = "#version 300 es\n            precision highp float;\n\n            uniform float u_opacity;\n\n            in vec4 v_color;\n            out vec4 outColor;\n\n            void main() {\n                outColor = v_color;\n                outColor.a = u_opacity;\n            }   \n            ";
+        var program = (0, webglobjectbuilders_1.createProgram)(gl, vertexSource, fragmentSource);
+        var a_position = gl.getAttribLocation(program, 'a_position');
+        var a_color = gl.getAttribLocation(program, 'a_color');
+        // vao and buffer. 
+        var vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._inBuffer);
+        gl.enableVertexAttribArray(a_position);
+        gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 6 * 4, 0);
+        gl.enableVertexAttribArray(a_color);
+        gl.vertexAttribPointer(a_color, 4, gl.FLOAT, false, 6 * 4, 2 * 4);
+        gl.bindVertexArray(null);
+        var cm = camerauniformblock_1.CameraUniformBlockTotemCache.get(globe);
+        var bindingPoint = 0;
+        var cmIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        gl.uniformBlockBinding(program, cmIndex, bindingPoint);
+        return {
+            program: program,
+            vao: vao,
+            u_point_size: gl.getUniformLocation(program, 'u_point_size'),
+            u_opacity: gl.getUniformLocation(program, 'u_opacity'),
+            bindCamera: function () { return cm.bind(bindingPoint); },
+            unbindCamera: function () { return cm.unbind(bindingPoint); }
+        };
+    };
+    ShapesOnGlobeProgram.prototype.draw = function (uProjectionMatrix, uModelViewMatrix, uTranslate, drawRanges) {
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper, _is3D = _a._is3D;
+        var deepTest = gl.isEnabled(gl.DEPTH_TEST);
+        gl.disable(gl.DEPTH_TEST);
+        gl.useProgram(_programWrapper.program);
+        gl.bindVertexArray(_programWrapper.vao);
+        gl.uniformMatrix4fv(_programWrapper.u_model_view_matrix, false, uModelViewMatrix);
+        gl.uniformMatrix4fv(_programWrapper.u_proj_matrix, false, uProjectionMatrix);
+        gl.uniform3f(_programWrapper.u_transpos, uTranslate.x, uTranslate.y, uTranslate.z);
+        gl.bindVertexArray(_programWrapper.vao);
+        _programWrapper.bindCamera();
+        if (!_is3D) {
+            var mapWH = this.globe.api_GetCurrentWorldWH();
+            gl.uniform2f(_programWrapper.u_mapWH, mapWH.width, mapWH.height);
+        }
+        for (var _i = 0, drawRanges_1 = drawRanges; _i < drawRanges_1.length; _i++) {
+            var drawRange = drawRanges_1[_i];
+            gl.drawArrays(this._drawMode, drawRange[0], drawRange[1]);
+            // gl.drawArrays(gl.POINTS, drawRange[0], 1);
+        }
+        _programWrapper.unbindCamera();
+        gl.bindVertexArray(null);
+        if (deepTest) {
+            gl.enable(gl.DEPTH_TEST);
+        }
+    };
+    ShapesOnGlobeProgram.prototype.setOpacity = function (opacity) {
+        if (opacity < 0 || opacity > 1) {
+            throw new Error('Invalid opacity value');
+        }
+        ;
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniform1f(_programWrapper.u_opacity, opacity);
+        gl.useProgram(currentProgram);
+        this.globe.DrawRender();
+    };
+    ShapesOnGlobeProgram.prototype.setPointSize = function (size) {
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniform1f(_programWrapper.u_point_size, size);
+        gl.useProgram(currentProgram);
+        this.globe.DrawRender();
+    };
+    ShapesOnGlobeProgram.prototype.setDrawMode = function (mode) {
+        var modegl = this._getDraw(mode);
+        if (modegl) {
+            this._drawMode = modegl;
+        }
+        else {
+            throw new Error('Invalid draw mode ' + mode);
+        }
+    };
+    ShapesOnGlobeProgram.prototype.setScreenWH = function () {
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper, globe = _a.globe;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniform2f(_programWrapper.u_scrWH, globe.api_ScrW(), globe.api_ScrH());
+        gl.useProgram(currentProgram);
+    };
+    ShapesOnGlobeProgram.prototype.resize = function (width, height) {
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper, globe = _a.globe;
+        width = width || globe.api_ScrW();
+        height = height || globe.api_ScrH();
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniform2f(_programWrapper.u_scrWH, width, height);
+        gl.useProgram(currentProgram);
+    };
+    ShapesOnGlobeProgram.prototype.setGeometry = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe, _programWrapper = _a._programWrapper;
+        this._is3D = globe.api_GetCurrentGeometry() === 0;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniform1f(_programWrapper.u_is3D, this._is3D ? 1.0 : 0.0);
+        gl.useProgram(currentProgram);
+        this.resize();
+    };
+    ShapesOnGlobeProgram.prototype.free = function () {
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper;
+        gl.deleteProgram(_programWrapper.program);
+        gl.deleteVertexArray(_programWrapper.vao);
+        gl.deleteBuffer(this._inBuffer);
+    };
+    /**
+     *
+     * @param {Float32Array} data
+     * @format [x, y, r, g, b, a, x, y, r, g, b, a, x, y, r, g, b, a, x, y, r, g, b, a]
+     */
+    ShapesOnGlobeProgram.prototype.setBufferData = function (data) {
+        var gl = this.gl;
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._inBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
+    };
+    return ShapesOnGlobeProgram;
+}());
+exports.ShapesOnGlobeProgram = ShapesOnGlobeProgram;

package/util/programs/supersampletotextures.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuperSampleTextureProgram = void 0;
+var webglobjectbuilders_1 = require("../webglobjectbuilders");
+var SuperSampleTextureProgram = /** @class */ (function () {
+    function SuperSampleTextureProgram(gl, internalFormat, sourceFormat, sourceType, glslOutputType, glslBand) {
+        if (internalFormat === void 0) { internalFormat = null; }
+        if (sourceFormat === void 0) { sourceFormat = null; }
+        if (sourceType === void 0) { sourceType = null; }
+        if (glslOutputType === void 0) { glslOutputType = "float"; }
+        if (glslBand === void 0) { glslBand = "r"; }
+        this._internalFormat = internalFormat || gl.R16F;
+        this._sourceFormat = sourceFormat || gl.RED;
+        this._sourceType = sourceType || gl.FLOAT;
+        this._glslOutputType = glslOutputType;
+        this._glslBand = glslBand;
+        this.gl = gl;
+        this._programWrapper = this._createProgramWrapper();
+        this._framebuffer = this.gl.createFramebuffer();
+    }
+    SuperSampleTextureProgram.prototype._createProgramWrapper = function () {
+        var _a = this, gl = _a.gl, _glslBand = _a._glslBand, _glslOutputType = _a._glslOutputType;
+        var vertexShaderSource = "#version 300 es\n        in vec2 a_position;\n        out vec2 v_texCoord;\n\n        uniform mat4 u_bbox_matrix;\n\n        void main() {\n            gl_Position = vec4(a_position, 0.0, 1.0);\n            v_texCoord = (u_bbox_matrix * vec4(a_position,0.0, 1.0)).xy;\n        }";
+        var fragmentShaderSource = "#version 300 es\n        precision highp float;\n        in vec2 v_texCoord;"
+            + "out ".concat(_glslOutputType, " outColor;")
+            + "uniform sampler2D u_texture;\n        void main() {"
+            + "   outColor = texture(u_texture, v_texCoord).".concat(_glslBand, ";")
+            + "}";
+        var program = (0, webglobjectbuilders_1.createProgram)(gl, vertexShaderSource, fragmentShaderSource);
+        var vao = gl.createVertexArray();
+        var positionBuffer = gl.createBuffer();
+        gl.bindVertexArray(vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+            -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);
+        var u_bbox_matrix = gl.getUniformLocation(program, "u_bbox_matrix");
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.uniformMatrix2fv(u_bbox_matrix, false, new Float32Array([
+            1, 0, 0, 0,
+            0, 1, 0, 0,
+            0, 0, 1, 0,
+            0, 0, 0, 1
+        ]));
+        gl.useProgram(program);
+        gl.useProgram(currentProgram);
+        return {
+            program: program,
+            vao: vao,
+            u_texture: gl.getUniformLocation(program, "u_texture"),
+            u_bbox_matrix: u_bbox_matrix
+        };
+    };
+    SuperSampleTextureProgram.prototype.createHigherResolutionTexture = function (targetWidth, targetHeight, sourceTexture) {
+        // save current state
+        var _a = this, gl = _a.gl, _internalFormat = _a._internalFormat, _sourceFormat = _a._sourceFormat, _sourceType = _a._sourceType;
+        var currentViewport = gl.getParameter(gl.VIEWPORT);
+        var resultTexture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, resultTexture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, _internalFormat, targetWidth, targetHeight, 0, _sourceFormat, _sourceType, null);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        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.bindFramebuffer(gl.FRAMEBUFFER, this._framebuffer);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, resultTexture, 0);
+        gl.viewport(0, 0, targetWidth, targetHeight);
+        gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        this._draw(sourceTexture);
+        // restore previous state
+        this.gl.viewport(currentViewport[0], currentViewport[1], currentViewport[2], currentViewport[3]);
+        return resultTexture;
+    };
+    SuperSampleTextureProgram.prototype._draw = function (texture) {
+        var currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
+        this.gl.useProgram(this._programWrapper.program);
+        this.gl.bindVertexArray(this._programWrapper.vao);
+        this.gl.activeTexture(this.gl.TEXTURE0);
+        this.gl.bindTexture(this.gl.TEXTURE_2D, texture);
+        this.gl.uniform1i(this._programWrapper.u_texture, 0);
+        this.gl.drawArrays(this.gl.TRIANGLE_FAN, 0, 4);
+        this.gl.bindVertexArray(null);
+        this.gl.useProgram(currentProgram);
+    };
+    SuperSampleTextureProgram.prototype.setBBox = function (x0, y0, x1, y1) {
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniformMatrix2fv(_programWrapper.u_bbox_matrix, false, new Float32Array([
+            1 / (x1 - x0), 0, -x0 / (x1 - x0), 0,
+            0, 1 / (y1 - y0), -y0 / (y1 - y0), 0,
+            0, 0, 1, 0,
+            0, 0, 0, 1
+        ]));
+        gl.useProgram(currentProgram);
+    };
+    return SuperSampleTextureProgram;
+}());
+exports.SuperSampleTextureProgram = SuperSampleTextureProgram;