@pirireis/webglobeplugins 0.9.10 → 0.9.11

package/util/picking/picker-displayer.js

@@ -5,14 +5,14 @@
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PickerDisplayer = void 0;
-const draw_texture_on_canvas_1 = require("../programs/draw-texture-on-canvas");
-const fence_1 = require("./fence");
-const ESCAPE_VALUE = -1;
-class PickerDisplayer {
-    constructor(globe) {
+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;
-        const gl = this.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();
@@ -21,37 +21,39 @@ class PickerDisplayer {
         this.resize();
         this.displayer = draw_texture_on_canvas_1.textureOnCanvasProgramCache.get(this.gl);
     }
-    resize(width = null, height = null) {
+    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();
         }
-        const { gl, colorTexture, indexTexture } = this;
+        var _a = this, gl = _a.gl, colorTexture = _a.colorTexture, indexTexture = _a.indexTexture;
         gl.deleteTexture(colorTexture);
         gl.deleteTexture(indexTexture);
-        const colorTextureNew = gl.createTexture();
+        var colorTextureNew = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, colorTextureNew);
         gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, width, height);
-        const indexTextureNew = gl.createTexture();
+        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;
-    }
-    clearTextures() {
-        const { gl, colorTexture, indexTexture } = this;
+    };
+    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
-    bindFBO() {
-        const { gl, colorTexture, indexTexture, fbo } = this;
+    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);
@@ -62,27 +64,30 @@ class PickerDisplayer {
             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
-    drawColorTexture() {
-        const { colorTexture } = this;
+    PickerDisplayer.prototype.drawColorTexture = function () {
+        var colorTexture = this.colorTexture;
         this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, null);
         this.displayer.draw(colorTexture);
-    }
-    pickXY(x, y, selectionPointFilling = 1, callback = () => { }) {
-        const size = Math.pow(1 + 2 * selectionPointFilling, 2);
+    };
+    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);
-    }
-    pickBbox(left, top, right, bottom, callback) {
-        const size = (right - left) * (bottom - top) * 4;
+    };
+    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);
-    }
-    _pick(size, startX, startY, lengthX, lengthY, 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);
-        const { gl, _pbo } = this;
+        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
@@ -90,35 +95,35 @@ class PickerDisplayer {
         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(() => {
+        (0, fence_1.fence)(this.gl).then(function () {
             gl.bindBuffer(gl.PIXEL_PACK_BUFFER, _pbo);
             // const data = new Int16Array(size);
-            const data = new Int32Array(size);
+            var data = new Int32Array(size);
             gl.getBufferSubData(gl.PIXEL_PACK_BUFFER, 0, data);
             gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
-            const result = this._pickFromBuffer(data, size);
+            var result = _this._pickFromBuffer(data, size);
             callback(result);
             // gl.deleteBuffer(pbo);
-            this._inProgress = false;
+            _this._inProgress = false;
         });
         return true;
-    }
-    _pickFromBuffer(array, size) {
-        const selectedObjects = new Set();
-        for (let i = 0; i < size; i += 1) {
-            const id = array[i];
+    };
+    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;
-    }
-    _initHoldBuffer(size) {
+    };
+    PickerDisplayer.prototype._initHoldBuffer = function (size) {
         if (this._pbo && this._pboSize >= size) {
             return;
         }
-        const { gl } = this;
-        const pbo = gl.createBuffer();
+        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);
@@ -127,13 +132,14 @@ class PickerDisplayer {
             gl.deleteBuffer(this._pbo);
         }
         this._pbo = pbo;
-    }
-    free() {
-        const { gl, colorTexture, indexTexture, fbo } = this;
+    };
+    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

@@ -1,33 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.textureOnCanvasProgramCache = void 0;
-const webglobjectbuilders_1 = require("../webglobjectbuilders");
-const programs_1 = require("../../programs");
+var webglobjectbuilders_1 = require("../webglobjectbuilders");
+var programs_1 = require("../../programs");
 // import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../../programs/totems";
-const vs = `#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;
-}`;
-const fs = `#version 300 es
-precision highp float;
-
-uniform sampler2D u_texture;
-uniform float u_opacity;    
-in vec2 v_texcoord;
-out vec4 fragColor;
-
-void main() {
-    fragColor = texture(u_texture, v_texcoord);
-    fragColor.a *= u_opacity;
-}`;
-class TextureOnCanvasProgram {
-    constructor(gl) {
+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();
@@ -45,22 +25,23 @@ class TextureOnCanvasProgram {
         this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
         this.program = (0, webglobjectbuilders_1.createProgram)(this.gl, vs, fs);
         {
-            const { gl, program } = this;
+            var _a = this, gl_1 = _a.gl, program = _a.program;
             this.uniforms = {
-                texture: gl.getUniformLocation(program, "u_texture"),
-                opacity: gl.getUniformLocation(program, "u_opacity"),
+                texture: gl_1.getUniformLocation(program, "u_texture"),
+                opacity: gl_1.getUniformLocation(program, "u_opacity"),
             };
         }
         {
             this._lastOpacity = 1.0;
-            const currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
+            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);
         }
     }
-    draw(texture, { opacity = 1.0 } = {}) {
-        const { gl, program, uniforms, vao } = this;
+    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);
@@ -72,18 +53,19 @@ class TextureOnCanvasProgram {
         }
         gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
         gl.bindVertexArray(null);
-    }
-    free() {
+    };
+    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;
-    }
-}
-const textureOnCanvasProgramCache = Object.freeze({
-    get: (gl) => programs_1.glProgramCache.getProgram(gl, TextureOnCanvasProgram),
-    release: (gl) => programs_1.glProgramCache.releaseProgram(gl, TextureOnCanvasProgram)
+    };
+    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/shapesonglobe.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShapesOnGlobeProgram = void 0;
-const webglobjectbuilders_1 = require("../webglobjectbuilders");
-const camerauniformblock_1 = require("../../programs/totems/camerauniformblock");
-const __1 = require("..");
+var webglobjectbuilders_1 = require("../webglobjectbuilders");
+var camerauniformblock_1 = require("../../programs/totems/camerauniformblock");
+var __1 = require("..");
 /** TODO:
  * 3d icin calistir
  */
-const drawModeFunc = (gl) => {
-    return (mode) => {
+var drawModeFunc = function (gl) {
+    return function (mode) {
         return {
             "point": gl.POINTS,
             "line": gl.LINES,
@@ -20,8 +20,9 @@ const drawModeFunc = (gl) => {
         }[mode];
     };
 };
-class ShapesOnGlobeProgram {
-    constructor(gl, globe, drawMode = 'point') {
+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);
@@ -32,9 +33,9 @@ class ShapesOnGlobeProgram {
         this._initUniforms();
         this.setScreenWH();
     }
-    _initUniforms() {
-        const { gl, _programWrapper } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+    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);
@@ -42,59 +43,16 @@ class ShapesOnGlobeProgram {
         gl.uniform1f(_programWrapper.height, 0.0);
         gl.uniform1f(_programWrapper.u_point_size, 1.0);
         gl.useProgram(currentProgram);
-    }
-    _createProgramWrapper() {
-        const { gl, globe } = this;
-        const vertexSource = `#version 300 es
-            precision highp float;
-            ${camerauniformblock_1.CameraUniformBlockString}
-
-            in vec2 a_position;
-            in vec4 a_color;
-
-
-            uniform bool u_is3D;
-            uniform float height; 
-
-            uniform float u_point_size;
-
-            out vec4 v_color;
-
-            ` + __1.shaderfunctions.pixelXYToCartesian3DPoint + `
-            ` + __1.shaderfunctions.pixelXYToCartesian2DPoint + `
-
-
-            void main() {
-                vec3 pos = vec3(a_position, height);
-                if(is3D){
-                    pos = pixelXYToCartesian3DPoint(pos);
-                    gl_Position = projection * view * vec4(pos - translate, 1.0);
-                } else {
-                    vec2 xy = pixelXYToCartesian2DPoint(pos.xy, translate.xy, mapWH, screenWH);
-                    gl_Position = projection * vec4(xy.x, xy.y, 0.0, 1.0);
-                }
-                gl_PointSize = u_point_size;
-                v_color = a_color;
-            }
-            `;
-        const fragmentSource = `#version 300 es
-            precision highp float;
-
-            uniform float u_opacity;
-
-            in vec4 v_color;
-            out vec4 outColor;
-
-            void main() {
-                outColor = v_color;
-                outColor.a = u_opacity;
-            }   
-            `;
-        const program = (0, webglobjectbuilders_1.createProgram)(gl, vertexSource, fragmentSource);
-        const a_position = gl.getAttribLocation(program, 'a_position');
-        const a_color = gl.getAttribLocation(program, 'a_color');
+    };
+    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. 
-        const vao = gl.createVertexArray();
+        var vao = gl.createVertexArray();
         gl.bindVertexArray(vao);
         gl.bindBuffer(gl.ARRAY_BUFFER, this._inBuffer);
         gl.enableVertexAttribArray(a_position);
@@ -102,22 +60,22 @@ class ShapesOnGlobeProgram {
         gl.enableVertexAttribArray(a_color);
         gl.vertexAttribPointer(a_color, 4, gl.FLOAT, false, 6 * 4, 2 * 4);
         gl.bindVertexArray(null);
-        const cm = camerauniformblock_1.CameraUniformBlockTotemCache.get(globe);
-        const bindingPoint = 0;
-        const cmIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        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: () => cm.bind(bindingPoint),
-            unbindCamera: () => cm.unbind(bindingPoint)
+            bindCamera: function () { return cm.bind(bindingPoint); },
+            unbindCamera: function () { return cm.unbind(bindingPoint); }
         };
-    }
-    draw(uProjectionMatrix, uModelViewMatrix, uTranslate, drawRanges) {
-        const { gl, _programWrapper, _is3D } = this;
-        const deepTest = gl.isEnabled(gl.DEPTH_TEST);
+    };
+    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);
@@ -127,10 +85,11 @@ class ShapesOnGlobeProgram {
         gl.bindVertexArray(_programWrapper.vao);
         _programWrapper.bindCamera();
         if (!_is3D) {
-            const mapWH = this.globe.api_GetCurrentWorldWH();
+            var mapWH = this.globe.api_GetCurrentWorldWH();
             gl.uniform2f(_programWrapper.u_mapWH, mapWH.width, mapWH.height);
         }
-        for (const drawRange of drawRanges) {
+        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);
         }
@@ -139,76 +98,77 @@ class ShapesOnGlobeProgram {
         if (deepTest) {
             gl.enable(gl.DEPTH_TEST);
         }
-    }
-    setOpacity(opacity) {
+    };
+    ShapesOnGlobeProgram.prototype.setOpacity = function (opacity) {
         if (opacity < 0 || opacity > 1) {
             throw new Error('Invalid opacity value');
         }
         ;
-        const { gl, _programWrapper } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        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();
-    }
-    setPointSize(size) {
-        const { gl, _programWrapper } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+    };
+    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();
-    }
-    setDrawMode(mode) {
-        const modegl = this._getDraw(mode);
+    };
+    ShapesOnGlobeProgram.prototype.setDrawMode = function (mode) {
+        var modegl = this._getDraw(mode);
         if (modegl) {
             this._drawMode = modegl;
         }
         else {
             throw new Error('Invalid draw mode ' + mode);
         }
-    }
-    setScreenWH() {
-        const { gl, _programWrapper, globe } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+    };
+    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);
-    }
-    resize(width, height) {
-        const { gl, _programWrapper, globe } = this;
+    };
+    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();
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(_programWrapper.program);
         gl.uniform2f(_programWrapper.u_scrWH, width, height);
         gl.useProgram(currentProgram);
-    }
-    setGeometry() {
-        const { gl, globe, _programWrapper } = this;
+    };
+    ShapesOnGlobeProgram.prototype.setGeometry = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe, _programWrapper = _a._programWrapper;
         this._is3D = globe.api_GetCurrentGeometry() === 0;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        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();
-    }
-    free() {
-        const { gl, _programWrapper } = this;
+    };
+    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]
      */
-    setBufferData(data) {
-        const { gl } = this;
+    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;