@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/programs/line-on-globe/degree-padding-around-circle-3d.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CirclePadding3DCache = void 0;
+var webglobjectbuilders_1 = require("../../util/webglobjectbuilders");
+var camerauniformblock_1 = require("../totems/camerauniformblock");
+var programcache_1 = require("../programcache");
+// import { vaoAttributeLoader } from "../../util/account/util";
+var attribute_loader_1 = require("../../util/gl-util/buffer/attribute-loader");
+var util_1 = require("./util");
+var geometrytransformations_1 = require("../../util/shaderfunctions/geometrytransformations");
+/**
+ * TODO:
+ * 1. integrate geometry functions for radius angle and center
+ * 2. integrate attributes
+ *
+ * TODO:
+ * center_position is too small or doenst loaded as expected.
+ */
+var INITIAL_EDGE_COUNT = 720;
+var vertexShaderSource = "#version 300 es\nprecision highp float;\n".concat(camerauniformblock_1.CameraUniformBlockString, "\n").concat(geometrytransformations_1.cartesian3DToGLPosition, "\n").concat(geometrytransformations_1.circleLimpFromLongLatRadCenterCartesian3D_accurate, "\n\n\nin vec3 center_position3d;\nin float big_radius;\nin float small_radius;\nin vec4 color;\n\nuniform float edge_count;\nuniform float step_angle;\nuniform int z_alpha_on;\n\nout float interpolation;\nout vec4 v_color;\nvoid main() {\n    if( !is3D) {\n        return;\n    }\n    v_color = color;\n    if ( z_alpha_on == 1 ){\n        float z_alpha = pow(z_level * 0.75, 3.0) * distance(big_radius, small_radius) / (R * 2.0);\n        if ( z_alpha < 0.1 ) { return; }\n        v_color.a *= z_alpha;\n    }\n    int pad_phase =  gl_VertexID % 2; // 0 or 1\n    interpolation = float( gl_VertexID - pad_phase) / edge_count;\n    float angle = float( gl_VertexID - pad_phase) * step_angle;\n    vec3 position;\n    if ( pad_phase == 0 ) {\n        position = circleLimpFromLongLatRadCenterCartesian3D_accurate(center_position3d, big_radius, angle);\n    } else {\n        position = circleLimpFromLongLatRadCenterCartesian3D_accurate(center_position3d, small_radius, angle);\n    }\n    gl_Position = cartesian3DToGLPosition(position);\n\n    gl_PointSize = 5.0;\n}");
+var fragmentShaderSource = "#version 300 es\n".concat(geometrytransformations_1.POLE, "\nprecision highp float;\nuniform float opacity;\nin vec4 v_color;\nin float interpolation;\nin vec2 v_limp;\nout vec4 color;\nvoid main() {\n    color = v_color;\n    color.a *= opacity;\n}\n");
+var Logic = /** @class */ (function () {
+    function Logic(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._lastOpacity = 1.0;
+        this._lastEdgeCount = INITIAL_EDGE_COUNT;
+        this._lastStepAngle = 720 / INITIAL_EDGE_COUNT;
+        this._lastZAlphaMode = util_1.Z_ALPHA_MODE.ON;
+        this.program = (0, webglobjectbuilders_1.createProgram)(this.gl, vertexShaderSource, fragmentShaderSource);
+        var _a = this, gl = _a.gl, program = _a.program;
+        this.program.uniforms = {
+            opacity: gl.getUniformLocation(program, "opacity"),
+            edgeCount: gl.getUniformLocation(program, "edge_count"),
+            stepAngle: gl.getUniformLocation(program, "step_angle"),
+            zAlphaMode: gl.getUniformLocation(program, "z_alpha_on")
+        };
+        { // initial uniform values
+            var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(program.uniforms.opacity, 1.0);
+            gl.uniform1f(program.uniforms.edgeCount, INITIAL_EDGE_COUNT * 2);
+            gl.uniform1f(program.uniforms.stepAngle, this._lastStepAngle * Math.PI / 360);
+            gl.uniform1i(program.uniforms.zAlphaMode, util_1.Z_ALPHA_MODE.ON);
+            gl.useProgram(currentProgram);
+        }
+        { // assign attribute locations
+            gl.bindAttribLocation(program, 0, "center_position3d");
+            gl.bindAttribLocation(program, 1, "big_radius");
+            gl.bindAttribLocation(program, 2, "small_radius");
+            gl.bindAttribLocation(program, 3, "color");
+        }
+        this.cameraBindingPoint = 0;
+        this.cameraBlockTotem = camerauniformblock_1.CameraUniformBlockTotemCache.get(globe);
+        var cameraBlockLocation = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        gl.uniformBlockBinding(program, cameraBlockLocation, this.cameraBindingPoint);
+    }
+    Logic.prototype.createVAO = function (center3dObj, bigRadiusObj, smallRadiusObj, colorObj) {
+        var gl = this.gl;
+        var vao = gl.createVertexArray();
+        var divisor = 1;
+        gl.bindVertexArray(vao);
+        (0, attribute_loader_1.attributeLoader)(gl, center3dObj, 0, 3, { divisor: divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, bigRadiusObj, 1, 1, { divisor: divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, smallRadiusObj, 2, 1, { divisor: divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, colorObj, 3, 4, { divisor: divisor });
+        gl.bindVertexArray(null);
+        return vao;
+    };
+    Logic.prototype.draw = function (vao, length, edgeCount, stepAngle, opacity, zAlphaMode) {
+        if (zAlphaMode === void 0) { zAlphaMode = util_1.Z_ALPHA_MODE.ON; }
+        var _a = this, gl = _a.gl, program = _a.program, cameraBlockTotem = _a.cameraBlockTotem, cameraBindingPoint = _a.cameraBindingPoint;
+        gl.useProgram(program);
+        if (this._lastOpacity !== opacity) {
+            gl.uniform1f(program.uniforms.opacity, opacity);
+            this._lastOpacity = opacity;
+        }
+        if (this._lastEdgeCount !== edgeCount) {
+            gl.uniform1f(program.uniforms.edgeCount, 2 * edgeCount);
+            this._lastEdgeCount = edgeCount;
+        }
+        if (this._lastStepAngle !== stepAngle) {
+            gl.uniform1f(program.uniforms.stepAngle, stepAngle * Math.PI / 360);
+            this._lastStepAngle = stepAngle;
+        }
+        if (this._lastZAlphaMode !== zAlphaMode) {
+            gl.uniform1i(program.uniforms.zAlphaMode, zAlphaMode);
+            this._lastZAlphaMode = zAlphaMode;
+        }
+        gl.bindVertexArray(vao);
+        cameraBlockTotem.bind(cameraBindingPoint);
+        gl.drawArraysInstanced(gl.LINES, 0, edgeCount * 2, length);
+        // gl.drawArraysInstanced(gl.POINTS, 0, edgeCount, length);
+        cameraBlockTotem.unbind(cameraBindingPoint);
+        gl.bindVertexArray(null);
+    };
+    Logic.prototype.free = function () {
+        if (this.isFreed)
+            return;
+        camerauniformblock_1.CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+        this.isFreed = true;
+    };
+    return Logic;
+}());
+exports.CirclePadding3DCache = Object.freeze({
+    get: function (globe) { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic); },
+    release: function (globe) { return programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic); }
+});

package/programs/line-on-globe/index.js

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

package/programs/line-on-globe/lines-color-instanced-flat.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Z_ALPHA_MODE = exports.LinesColorInstancedFlatCache = void 0;
+var totems_1 = require("../totems");
+var geometrytransformations_1 = require("../../util/shaderfunctions/geometrytransformations");
+var programcache_1 = require("../programcache");
+var util_1 = require("../../util");
+var util_2 = require("./util");
+Object.defineProperty(exports, "Z_ALPHA_MODE", { enumerable: true, get: function () { return util_2.Z_ALPHA_MODE; } });
+var attribute_loader_1 = require("../../util/gl-util/buffer/attribute-loader");
+/**
+ * This program draws line between points provided from the first and second buffer.
+ * draw method gl.drawArraysInstanced( gl.POINTS, 0,2, lineCount);
+ * */
+// TODO: find better way to eleminate edge case distance(posA, posB) > 37000000.0
+var vertexShaderSource = "#version 300 es\nprecision highp float;\n".concat(totems_1.CameraUniformBlockString, "\n").concat(geometrytransformations_1.mercatorXYToGLPosition, "\nuniform float opacity;\nuniform int z_alpha_on;\n\nin vec2 posA;\nin vec2 posB;\nin vec4 color;\n\nout vec2 v_frame;\nout vec4 v_color;\nvoid main() {\n    \n    if ( is3D ) {\n        return;\n    }\n    float gap = max( distance(posA.x, posB.x), distance(posA.y,posB.y)); // \n    if ( gap > 37000000.0) { return; }\n    float z_alpha;\n    if ( z_alpha_on == 1 ){ \n        z_alpha =  pow(2.0,z_level+1.0) /  ( 10000000.0 / gap);\n        z_alpha = smoothstep(0.1,0.9, z_alpha);\n        if( z_alpha < 0.01) {return;}\n    } else {\n        z_alpha = 1.0;\n    }\n        vec2 pos;\n    if ( gl_VertexID == 0 ) {\n        pos = posA;\n        } else {\n            pos = posB;\n    }\n    v_frame = pos;\n    gl_Position = mercatorXYToGLPosition( pos );\n    v_color = color;\n    v_color.a *= z_alpha * opacity;\n    gl_PointSize = 4.0;\n}");
+var fragmentShaderSource = "#version 300 es\n".concat(geometrytransformations_1.POLE, "\nprecision highp float;\nin vec4 v_color;\nin vec2 v_frame;\nout vec4 outColor;\nvoid main() {\n    if ( v_frame.x < -POLE || v_frame.x > POLE || v_frame.y < -POLE || v_frame.y > POLE ){ discard; }\n    outColor = v_color;\n}");
+var Logic = /** @class */ (function () {
+    function Logic(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = (0, util_1.createProgram)(this.gl, vertexShaderSource, fragmentShaderSource);
+        this._lastOpicity = 1.0;
+        this._lastZAlphaOn = util_2.Z_ALPHA_MODE.OFF;
+        var _a = this, gl = _a.gl, program = _a.program;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(program);
+        { // assign attribute locations
+            gl.bindAttribLocation(program, 0, 'posA');
+            gl.bindAttribLocation(program, 1, 'posB');
+            gl.bindAttribLocation(program, 2, 'color');
+        }
+        { // uniform locations
+            this._opacityLocation = gl.getUniformLocation(program, 'opacity');
+            this._zAlphaOnLocation = gl.getUniformLocation(program, 'z_alpha_on');
+            gl.uniform1i(this._zAlphaOnLocation, this._lastZAlphaOn);
+            gl.uniform1f(this._opacityLocation, this._lastOpicity);
+        }
+        { // uniform block
+            this._cameraUniformBlock = totems_1.CameraUniformBlockTotemCache.get(globe);
+            this._cameraBindingPoint = 0;
+            var cameraBlockBindingIndex = gl.getUniformBlockIndex(program, 'CameraUniformBlock');
+            gl.uniformBlockBinding(program, cameraBlockBindingIndex, this._cameraBindingPoint);
+        }
+        gl.useProgram(currentProgram);
+    }
+    Logic.prototype.createVAO = function (posAObj, posBObj, colorObj) {
+        var gl = this.gl;
+        var vao = gl.createVertexArray();
+        var divisor = 1;
+        gl.bindVertexArray(vao);
+        (0, attribute_loader_1.attributeLoader)(gl, posAObj, 0, 2, { divisor: divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, posBObj, 1, 2, { divisor: divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, colorObj, 2, 4, { divisor: divisor });
+        gl.bindVertexArray(null);
+        return vao;
+    };
+    Logic.prototype.draw = function (vao, lineCount, opacity, zAlphaOn) {
+        if (opacity === void 0) { opacity = 1.0; }
+        if (zAlphaOn === void 0) { zAlphaOn = util_2.Z_ALPHA_MODE.ON; }
+        var _a = this, gl = _a.gl, program = _a.program, _cameraBindingPoint = _a._cameraBindingPoint, _cameraUniformBlock = _a._cameraUniformBlock;
+        gl.useProgram(program);
+        _cameraUniformBlock.bind(_cameraBindingPoint);
+        gl.bindVertexArray(vao);
+        if (this._lastOpicity !== opacity) {
+            this._lastOpicity = opacity;
+            gl.uniform1f(this._opacityLocation, opacity);
+        }
+        if (this._lastZAlphaOn !== zAlphaOn) {
+            this._lastZAlphaOn = zAlphaOn;
+            gl.uniform1i(this._zAlphaOnLocation, zAlphaOn);
+        }
+        gl.drawArraysInstanced(gl.LINES, 0, 2, lineCount);
+        _cameraUniformBlock.unbind(_cameraBindingPoint);
+        gl.bindVertexArray(null);
+    };
+    Logic.prototype.free = function () {
+        if (this.isFreed)
+            return;
+        var _a = this, gl = _a.gl, program = _a.program, globe = _a.globe;
+        totems_1.CameraUniformBlockTotemCache.release(globe);
+        gl.deleteProgram(program);
+        this.isFreed = true;
+    };
+    return Logic;
+}());
+var LinesColorInstancedFlatCache = Object.freeze({
+    get: function (globe) { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic); },
+    release: function (globe) { programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic); }
+});
+exports.LinesColorInstancedFlatCache = LinesColorInstancedFlatCache;

package/programs/line-on-globe/linestrip.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineStripProgramCache = void 0;
+var webglobjectbuilders_1 = require("../../util/webglobjectbuilders");
+require("../interface");
+var totems_1 = require("../totems");
+var geometrytransformations_js_1 = require("../../util/shaderfunctions/geometrytransformations.js");
+var programcache_1 = require("../programcache");
+var attribute_loader_1 = require("../../util/gl-util/buffer/attribute-loader");
+require("../../util/gl-util/buffer/attribute-loader");
+var manager_1 = require("../../util/gl-util/uniform-block/manager");
+require("../../util/gl-util/uniform-block/types");
+var methods_1 = require("../../util/gl-util/draw-options/methods");
+require("../../util/gl-util/draw-options/types");
+var ESCAPE_VALUE = -1;
+var uniformBindingPoints = {
+    camera: 0,
+    flexible: 1,
+};
+var one = new Float32Array([1]);
+var flexibleBlockManager = new manager_1.UniformBlockManager('FlexibleAttributes', [
+    { name: "u_color", type: "vec4", value: new Float32Array([0.12, 1, 0.1, 1]) },
+    { name: "u_dash_opacity", type: "float", value: one },
+    { name: "u_dash_length", type: "float", value: one },
+], uniformBindingPoints.flexible);
+var vertexShaderSource = "#version 300 es\nprecision highp float;\n\n".concat(totems_1.CameraUniformBlockString, "\n").concat(geometrytransformations_js_1.cartesian3DToGLPosition, "\n").concat(geometrytransformations_js_1.mercatorXYToGLPosition, "\n\n").concat(flexibleBlockManager.glslCode(), "\n\nin vec3 position3d;\nin vec2 position2d;\nin vec4 color; \nin float dash_length;\nin float dash_opacity;\n\nout float v_dash_length;\nout float v_dash_opacity;\nout vec4 v_color;\n\nflat out vec3 v_flat_position;\nout vec3 v_position;\n\nvoid main() {\n\n    v_color = ( color.r == -1.0 ) ? u_color : color;\n    v_dash_length = ( dash_length == -1.0 ) ? u_dash_length : dash_length;\n    v_dash_opacity = ( dash_opacity == -1.0 ) ? u_dash_opacity : dash_opacity;\n\n    if ( is3D ) {\n        gl_Position = cartesian3DToGLPosition( position3d );\n        v_position = position3d;\n        v_flat_position = position3d;\n    } else {\n        gl_Position = mercatorXYToGLPosition( position2d );\n        v_position = vec3( position2d, 0.0 );\n        v_flat_position = vec3( position2d, 0.0 );\n    }\n    gl_PointSize = 4.0;\n}");
+var fragmentShaderSource = "#version 300 es\nprecision highp float;\n\nuniform float opacity;\n\nin vec4 v_color;\nin float v_dash_length;\nin float v_dash_opacity;\n\nflat in vec3 v_flat_position;\nin vec3 v_position;\n\n\nout vec4 outColor;\n\nvoid main() {\n    outColor = v_color;\n    return;\n    float dash_length = v_dash_length;\n    float dash_opacity = v_dash_opacity;\n\n    if ( dash_length == 0.0 ) {\n        outColor = vec4( v_color.rgb, v_color.a * v_dash_opacity );\n    } else {\n        float dist = distance( v_flat_position, v_position );\n        // float alpha = mod( dist , v_dash_length * 2.0 ) / v_dash_length < 1.0 ? 1.0 : v_dash_opacity;\n        outColor = vec4( v_color.rgb,  v_color.a * opacity );\n    }\n}";
+console.log("LineStripProgram");
+console.log(vertexShaderSource);
+console.log(fragmentShaderSource);
+var Logic = /** @class */ (function () {
+    function Logic(globe) {
+        this._vaosPublished = [];
+        this._ubosPublished = [];
+        this._opacity = {
+            value: 1,
+            location: null
+        };
+        console.log("LineStripProgram globe", globe);
+        this.gl = globe.gl;
+        this.globe = globe;
+        this.program = (0, webglobjectbuilders_1.createProgram)(this.gl, vertexShaderSource, fragmentShaderSource);
+        var currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
+        this.gl.useProgram(this.program);
+        this._opacity.location = this.gl.getUniformLocation(this.program, "opacity");
+        this.gl.uniform1f(this._opacity.location, this._opacity.value);
+        // bind attribute locations
+        this.gl.bindAttribLocation(this.program, 0, "position3d");
+        this.gl.bindAttribLocation(this.program, 1, "position2d");
+        this.gl.bindAttribLocation(this.program, 2, "color");
+        this.gl.bindAttribLocation(this.program, 3, "dash_length");
+        this.gl.bindAttribLocation(this.program, 4, "dash_opacity");
+        this.cameraBlockTotem = totems_1.CameraUniformBlockTotemCache.get(globe);
+        this.cameraBlockTotem.assignBindingPoint(this.program, uniformBindingPoints.camera);
+        flexibleBlockManager.assignBindingPoint(this.gl, this.program);
+        this._defaultFlexibleUBO = flexibleBlockManager.createUBO(this.gl);
+        this.gl.useProgram(currentProgram);
+    }
+    Logic.prototype.createUBO = function (bufferReadType) {
+        if (bufferReadType === void 0) { bufferReadType = "STATIC_DRAW"; }
+        var ubo = flexibleBlockManager.createUBO(this.gl, bufferReadType);
+        this._ubosPublished.push(ubo);
+        return ubo;
+    };
+    Logic.prototype.createVAO = function (position3D, position2D, color, dashLength, dashOpacity) {
+        var gl = this.gl;
+        var vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        (0, attribute_loader_1.attributeLoader)(gl, position3D, 0, 3);
+        (0, attribute_loader_1.attributeLoader)(gl, position2D, 1, 2);
+        (0, attribute_loader_1.attributeLoader)(gl, color, 2, 4, { escapeValues: [ESCAPE_VALUE, ESCAPE_VALUE, ESCAPE_VALUE, ESCAPE_VALUE] });
+        (0, attribute_loader_1.attributeLoader)(gl, dashLength, 3, 1, { escapeValues: [ESCAPE_VALUE] });
+        (0, attribute_loader_1.attributeLoader)(gl, dashOpacity, 4, 1, { escapeValues: [ESCAPE_VALUE] });
+        gl.bindVertexArray(null);
+        return vao;
+    };
+    Logic.prototype.draw = function (vao, drawOptions, opacity, flexibleUBO) {
+        if (opacity === void 0) { opacity = 1; }
+        if (flexibleUBO === void 0) { flexibleUBO = null; }
+        var _a = this, gl = _a.gl, program = _a.program, cameraBlockTotem = _a.cameraBlockTotem;
+        gl.useProgram(program);
+        if (opacity !== this._opacity.value) {
+            this._opacity.value = opacity;
+            this.gl.uniform1f(this._opacity.location, this._opacity.value);
+        }
+        var ubo = flexibleUBO || this._defaultFlexibleUBO;
+        cameraBlockTotem.bind(uniformBindingPoints.camera);
+        ubo.bind();
+        gl.bindVertexArray(vao);
+        (0, methods_1.drawArrays)(gl, gl.POINTS, drawOptions);
+        (0, methods_1.drawArrays)(gl, gl.LINE_STRIP, drawOptions);
+        gl.bindVertexArray(null);
+        ubo.unbind();
+        cameraBlockTotem.unbind(uniformBindingPoints.camera);
+    };
+    Logic.prototype.free = function () {
+        var _this = this;
+        this._vaosPublished.forEach(function (vao) { return _this.gl.deleteVertexArray(vao); });
+        this._ubosPublished.forEach(function (ubo) { return ubo.free(); });
+        this.gl.deleteProgram(this.program);
+        this._defaultFlexibleUBO.free();
+        totems_1.CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+    };
+    return Logic;
+}());
+exports.LineStripProgramCache = Object.freeze({
+    get: function (globe) { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic); },
+    release: function (globe) { return programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic); },
+});

package/programs/line-on-globe/naive-accurate-flexible.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineOnGlobeCache = void 0;
+var totems_1 = require("../totems");
+var geometrytransformations_1 = require("../../util/shaderfunctions/geometrytransformations");
+var util_1 = require("../../util");
+var programcache_1 = require("../programcache");
+var attribute_loader_1 = require("../../util/gl-util/buffer/attribute-loader");
+var manager_1 = require("../../util/gl-util/uniform-block/manager");
+require("../../util/gl-util/draw-options/types");
+var methods_1 = require("../../util/gl-util/draw-options/methods");
+var GLOBE_MIDPOINT_COUNT = 30;
+var escapeValue = -1.0;
+var uniformBindingPoints = {
+    camera: 0,
+    flexible: 1
+};
+var uniformBlockManager = new manager_1.UniformBlockManager('FlexibleAttibutes', [
+    { name: 'u_color', type: 'vec4' },
+    { name: 'u_dash_ratio', type: 'float' },
+    { name: 'u_dash_opacity', type: 'float' }
+], uniformBindingPoints.flexible);
+var vertexShader = "#version 300 es\nprecision highp float;\n\n".concat(geometrytransformations_1.R_3D, "\n").concat(totems_1.CameraUniformBlockString, "\n").concat(geometrytransformations_1.slerp, "\n").concat(geometrytransformations_1.mercatorXYToGLPosition, "\n").concat(geometrytransformations_1.cartesian3DToGLPosition, "\n\n").concat(uniformBlockManager.glslCode(), "\n\nin vec2 start_position;\nin vec3 start_position3d;\nin vec2 end_position;\nin vec3 end_position3d;\n\nin float dash_ratio;\nin float dash_opacity;\nin vec4 color;\n\nout float v_dash_ratio;\nout float v_dash_opacity;\nout vec4 v_color;\n\nout vec2 v_limp;\nout float interpolation;\n\nvoid main() {\n    vec2 longLat;\n\n    v_color = (color.r == -1.0) ? u_color: color;\n    v_dash_ratio = (dash_ratio == -1.0) ? u_dash_ratio : dash_ratio;\n    v_dash_opacity = (dash_opacity == -1.0) ? u_dash_opacity : dash_opacity;\n\n    if (is3D) {\n        interpolation = float(gl_VertexID) / ").concat(GLOBE_MIDPOINT_COUNT - 1, ".0;\n        vec3 cartesian = slerp(start_position3d, end_position3d, interpolation);\n        gl_Position = cartesian3DToGLPosition(cartesian);\n        v_limp = vec2(0.0, 0.0);\n    } else {\n        if ( distance( start_position, end_position) > 30000000.0) { return; }\n        interpolation = float(gl_VertexID);\n        if (gl_VertexID % 2 == 0) {\n            longLat = start_position;\n        } else {\n            longLat = end_position;\n        }\n        v_limp = longLat;\n        gl_Position = mercatorXYToGLPosition(longLat);\n    }\n}\n");
+var fragmentShader = "#version 300 es\n".concat(geometrytransformations_1.POLE, "\nprecision highp float;\n\nuniform float opacity;\n\nin float interpolation;\nin vec2 v_limp;\nin vec4 v_color;\nin float v_dash_ratio;\nin float v_dash_opacity;\n\nout vec4 color;\n\nvoid main() {\n    if (v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE) { discard; }\n    color = v_color;\n    color.a *= opacity;\n    if ( v_dash_ratio >= 1.0 ) { return; }\n    if (interpolation > 0.95) { return; }\n    if (fract(interpolation / (2.0 * v_dash_ratio)) < 0.5) { color.a *= v_dash_opacity; }\n\n}\n");
+var Logic = /** @class */ (function () {
+    function Logic(globe) {
+        this.vaosPublished = [];
+        this.isFreed = false;
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = (0, util_1.createProgram)(this.gl, vertexShader, fragmentShader);
+        this._lastOpacity = 1.0;
+        var _a = this, gl = _a.gl, program = _a.program;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(program);
+        // assign attribute locations
+        gl.bindAttribLocation(program, 0, "start_position");
+        gl.bindAttribLocation(program, 1, "start_position3d");
+        gl.bindAttribLocation(program, 2, "end_position");
+        gl.bindAttribLocation(program, 3, "end_position3d");
+        gl.bindAttribLocation(program, 4, "dash_ratio");
+        gl.bindAttribLocation(program, 5, "dash_opacity");
+        gl.bindAttribLocation(program, 6, "color");
+        this._opacityLocation = gl.getUniformLocation(program, "opacity");
+        gl.uniform1f(this._opacityLocation, this._lastOpacity);
+        gl.useProgram(currentProgram);
+        this.cameraBlockTotem = totems_1.CameraUniformBlockTotemCache.get(globe);
+        this.cameraBlockTotem.assignBindingPoint(program, uniformBindingPoints.camera);
+        this._ubosPublished = [];
+        uniformBlockManager.assignBindingPoint(this.gl, this.program);
+        this._defaultFlexibleUBO = this.createUBO();
+    }
+    /**
+     *
+     * @param {*} vao
+     * @param {DrawRangeIndexParams} drawOptions
+     * @param {number} opacity
+     * @param {Object} flexibleOptions
+     * @param {Array<number, number, number, number>} flexibleOptions.color // 0-1
+     * @param {number} flexibleOptions.dash_opacity
+     * @param {number} flexibleOptions.dash_ratio
+     */
+    Logic.prototype.draw = function (vao, drawOptions, opacity, flexibleUBO) {
+        if (flexibleUBO === void 0) { flexibleUBO = null; }
+        var _a = this, gl = _a.gl, program = _a.program, globe = _a.globe, cameraBlockTotem = _a.cameraBlockTotem, _defaultFlexibleUBO = _a._defaultFlexibleUBO;
+        gl.useProgram(program);
+        cameraBlockTotem.bind(uniformBindingPoints.camera);
+        gl.bindVertexArray(vao);
+        if (opacity !== this._lastOpacity) {
+            gl.uniform1f(this._opacityLocation, opacity);
+            this._lastOpacity = opacity;
+        }
+        // this._setFlexibleUniforms(flexibleOptions);
+        var vertexCount = globe.api_GetCurrentGeometry() === 0 ? GLOBE_MIDPOINT_COUNT : 2;
+        var ubo = flexibleUBO || _defaultFlexibleUBO;
+        ubo.bind();
+        (0, methods_1.drawInstanced)(gl, gl.LINE_STRIP, drawOptions, vertexCount);
+        ubo.unbind();
+        gl.bindVertexArray(null);
+        cameraBlockTotem.unbind(uniformBindingPoints.camera);
+    };
+    Logic.prototype.createUBO = function (bufferReadType) {
+        if (bufferReadType === void 0) { bufferReadType = "STATIC_DRAW"; }
+        var ubo = uniformBlockManager.createUBO(this.gl, bufferReadType);
+        this._ubosPublished.push(ubo);
+        ubo.update(new Map([
+            ["u_color", [1, 1, 1, 1]],
+            ["u_dash_ratio", [1]],
+            ["u_dash_opacity", [1]]
+        ]));
+        return ubo;
+    };
+    Logic.prototype.createVAO = function (startPotision2DBufferObj, startPotision3DBufferObj, endPosition2DBufferObj, endPosition3DBufferObj, dashRatioBufferObj, dashOpacityBufferObj, colorBufferObj) {
+        var gl = this.gl;
+        var vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        var divisor = 1;
+        (0, attribute_loader_1.attributeLoader)(gl, startPotision2DBufferObj, 0, 2, { divisor: divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, startPotision3DBufferObj, 1, 3, { divisor: divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, endPosition2DBufferObj, 2, 2, { divisor: divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, endPosition3DBufferObj, 3, 3, { divisor: divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, dashRatioBufferObj, 4, 1, { divisor: divisor, escapeValues: [escapeValue] });
+        (0, attribute_loader_1.attributeLoader)(gl, dashOpacityBufferObj, 5, 1, { divisor: divisor, escapeValues: [escapeValue] });
+        (0, attribute_loader_1.attributeLoader)(gl, colorBufferObj, 6, 4, { divisor: divisor, escapeValues: [escapeValue, escapeValue, escapeValue, escapeValue] });
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this.vaosPublished.push(vao);
+        return vao;
+    };
+    Logic.prototype.free = function () {
+        var _this = this;
+        if (this.isFreed)
+            return;
+        totems_1.CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+        this.vaosPublished.forEach(function (vao) { return _this.gl.deleteVertexArray(vao); });
+        this._ubosPublished.forEach(function (ubo) { return ubo.free(); });
+        this.isFreed = true;
+    };
+    return Logic;
+}());
+exports.LineOnGlobeCache = Object.freeze({
+    get: function (globe) { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic); },
+    release: function (globe) { return programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic); }
+});

package/programs/line-on-globe/to-the-surface.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("./util");
+var totems_1 = require("../totems");
+var geometrytransformations_1 = require("../../util/shaderfunctions/geometrytransformations");
+var programcache_1 = require("../programcache");
+var attribute_loader_1 = require("../../util/gl-util/buffer/attribute-loader");
+require("../draw-options/types");
+var methods_1 = require("../draw-options/methods");
+var vs = "#version 300 es\n".concat(geometrytransformations_1.R_3D, "\n").concat(totems_1.CameraUniformBlockString, "\n").concat(geometrytransformations_1.cartesian3DToGLPosition, "\nin vec3 pos3D\nin vec4 color;\nout float ratio;\nout flat vec4 vColor;\nvoid main(){\n if ( gl_VertexID  == 0) {\n  gl_Position = cartesian3DToGLPosition(pos3D);\n  ratio =0.0;\n } else {\n  vec3 sea_level_pos3D = norm(pos3D) * R_3D;\n  gl_Position = cartesian3DToGLPosition(pos3D);\n  ratio = 1.0;\n }\n vColor = color;   \n}");
+var fs = "#version 300 es\nuniform float opacity;\nuniform float phase;\nuniform float fadeOpacity;\nin flat vec4 vColor;\nin float ratio;\nout vec4 fragColor;\nvoid main(){\n fragColor = vec4( vColor.rgb, vColor.a * opacity);\n if (fadeOpacity < 1.0) {\n  float alpha= mix( fadeOpacity, vColor.a, fract( ratio + phase ));\n  fragColor.a *= alpha;\n } \n}";
+var Logic = /** @class */ (function () {
+    function Logic(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = (0, util_1.createProgram)(this.gl, vs, fs);
+        var _a = this, gl = _a.gl, program = _a.program;
+        this._opacity = {
+            lastValue: 1.0,
+            location: gl.getUniformLocation(program, 'opacity')
+        };
+        this._phase = {
+            lastValue: 1.0,
+            location: gl.getUniformLocation(program, 'phase')
+        };
+        this._fadeOpacity = {
+            lastValue: 1.0,
+            location: gl.getUniformBlockLocation(program, 'fadeOpacity')
+        };
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(program);
+        [this._opacity, this._phase, this._fadeOpacity].forEach(function (wrapper) { return gl.uniform1f(wrapper.location, wrapper.lastValue); });
+        gl.useProgram(currentProgram);
+        gl.useProgram(program);
+        gl.bindAttribLocation(program, 0, 'pos3D');
+        gl.bindAttribLocation(program, 1, 'color');
+        this.cameraUniformBlockTotem = new totems_1.CameraUniformBlockTotemCache.get(globe);
+        this.cameraBlockBindingPoint = 0;
+        var cameraBlockIndex = gl.getUniformBlockLocation(program, 'CameraUniformBlock');
+        gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
+    }
+    Logic.prototype.createVao = function (pos3DObj, colorObj) {
+        var gl = this.gl;
+        var vao = gl.createVertexArray();
+        var divisor = 1;
+        gl.bindVertexArray(vao);
+        (0, attribute_loader_1.attributeLoader)(gl, pos3DObj, 0, 3, { divisor: divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, colorObj, 1, 4, { divisor: divisor, escapeValue: [-1, -1, -1, -1] });
+        gl.bindVertexArray(null);
+        this._vaoCache.push(vao);
+        return vao;
+    };
+    /**
+     *
+     * @param {WebGL2RenderingContext.vertexArrayObject} vao
+     * @param {Render} drawOptions
+     */
+    Logic.prototype.draw = function (vao, drawOptions, _a) {
+        var _b = _a.opacity, opacity = _b === void 0 ? 1.0 : _b, _c = _a.fadeOpacity, fadeOpacity = _c === void 0 ? 1.0 : _c;
+        var _d = this, globe = _d.globe, gl = _d.gl, program = _d.program, _opacity = _d._opacity, _fadeOpacity = _d._fadeOpacity;
+        gl.useProgram(program);
+        gl.bindVertexArray(vao);
+        if (fadeOpacity < 1.0) {
+            this._updatePhase();
+            globe.drawRender();
+        }
+        if (fadeOpacity !== _fadeOpacity.lastValue) {
+            _fadeOpacity.lastValue = fadeOpacity;
+            gl.uniform1f(_fadeOpacity.location, fadeOpacity);
+        }
+        if (opacity !== _opacity.lastValue) {
+            _opacity.lastValue = opacity;
+            gl.uniform1f(_opacity.location, opacity);
+        }
+        (0, methods_1.drawInstanced)(gl, gl.TRIANGLE_FAN, drawOptions);
+    };
+    Logic.prototype._updatePhase = function () {
+        this._phase.lastValue = (Date.now() / 3.0) % 1000;
+        gl.uniform1f(_phase.location, _phase.lastValue);
+    };
+    return Logic;
+}());

package/programs/line-on-globe/util.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Z_ALPHA_MODE = void 0;
+var Z_ALPHA_MODE = Object.freeze({
+    ON: 1,
+    OFF: 0
+});
+exports.Z_ALPHA_MODE = Z_ALPHA_MODE;

package/programs/picking/pickable-renderer.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PickableRendererProgramCache = void 0;
+var util_1 = require("../../util");
+var totems_1 = require("../totems");
+var geometrytransformations_1 = require("../../util/shaderfunctions/geometrytransformations");
+var programcache_1 = require("../programcache");
+require("../../util/gl-util/draw-options/types");
+var methods_1 = require("../../util/gl-util/draw-options/methods");
+var attribute_loader_1 = require("../../util/gl-util/buffer/attribute-loader");
+var manager_1 = require("../../util/gl-util/uniform-block/manager");
+var uniformBindingPoints = {
+    camera: 0,
+    flexible: 1
+};
+var uniformBlockManager = new manager_1.UniformBlockManager("FlexibleBlock", [
+    { name: "u_rgba", type: "vec4", value: new Float32Array([1, 1, 1, 1]) },
+    { name: "u_opacity", type: "float", value: new Float32Array([1.0]) },
+    { name: "u_size_multiplier", type: "float", value: new Float32Array([1.0]) },
+    { name: "u_size", type: "float", value: new Float32Array([1.0]) },
+    { name: "u_minimum_size", type: "float", value: new Float32Array([1.0]) },
+    { name: "u_draw_mode", type: "int", value: new Int32Array([0]) }, // 0.0 for point, 1.0 for line
+    { name: "u_is_circle", type: "bool", value: new Float32Array([1.0]) },
+    { name: "u_dash_count", type: "float", value: new Float32Array([1.0]) },
+    { name: "u_dash_opacity_multiplier", type: "float", value: new Float32Array([1.0]) },
+    { name: "u_dash_phase", type: "float", value: new Float32Array([0.0]) },
+], uniformBindingPoints.flexible);
+var vs = "#version 300 es\n".concat(geometrytransformations_1.R, "\n").concat(geometrytransformations_1.R_3D, "\n").concat(totems_1.CameraUniformBlockString, "\n").concat(geometrytransformations_1.mercatorXYToGLPosition, "\n").concat(geometrytransformations_1.cartesian3DToGLPosition, "\n\n").concat(uniformBlockManager.glslCode(), "\n\nprecision highp float;\nprecision highp int;\n\nin vec3 pos3D;\nin vec2 pos2D;\nin vec4 rgba;\nin float size;\n\n\nflat out highp int vVertexID;\n\nout vec4 v_rgba;\n\nout float v_length;\n\nvoid main() {\n    \n    v_rgba =  (rgba.r == -1.0) ? u_rgba : rgba;\n    v_rgba.a *= u_opacity;\n    gl_PointSize = max(((size == -1.0) ? u_size : size) * u_size_multiplier, u_minimum_size);\n    \n    float size_fixer; \n    if(is3D){\n        gl_Position = cartesian3DToGLPosition(pos3D);\n        size_fixer = smoothstep(0.15, 1.0, 0.5 * R_3D / gl_Position.w) ;\n    } else {\n        gl_Position = mercatorXYToGLPosition(pos2D);\n        size_fixer = smoothstep(2.0, 5.2, z_level);\n    }\n    gl_PointSize *= size_fixer;\n    switch (u_draw_mode) {\n        case 0:\n            vVertexID = gl_VertexID;\n            break;\n        case 1:\n            v_length = float(gl_VertexID % 2);\n            vVertexID = (gl_VertexID - gl_VertexID % 2) / 2; // a line takes two points\n            break;\n        default:\n            break;\n    }\n}");
+var fs = "#version 300 es\nprecision highp float;\nprecision highp int;\n\n".concat(uniformBlockManager.glslCode(), "\n\nflat in highp int vVertexID;\n\nin vec4 v_rgba;\nin float v_length;\n\nlayout(location = 0) out vec4 fragColor;\nlayout(location = 1) out int vertexID;\n\nvoid main() {\n    vertexID = vVertexID; \n    fragColor = v_rgba;\n\n    switch (u_draw_mode) {\n        case 0:\n            float d = distance(gl_PointCoord, vec2(0.5, 0.5));\n            if (u_is_circle) {\n                if (d > 0.5) discard;\n                fragColor.a *= smoothstep(0.5, 0.45, d);\n            }\n            if (u_dash_opacity_multiplier < 1.0) {\n                float dash = sin(d * 3.14159 * 2.0 * u_dash_count + u_dash_phase) * (1.0 - u_dash_opacity_multiplier) + u_dash_opacity_multiplier;\n                fragColor.a *= dash;\n            }\n            break;\n        case 1:\n            if (u_dash_opacity_multiplier < 1.0 && fract((v_length + u_dash_phase) * u_dash_count) < 0.5) {\n                fragColor.a *= u_dash_opacity_multiplier;\n            }\n            break;\n    }\n}");
+var PointOnGlobeProgram = /** @class */ (function () {
+    function PointOnGlobeProgram(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._isFreed = false;
+        this.program = (0, util_1.createProgram)(this.gl, vs, fs);
+        var _a = this, gl = _a.gl, program = _a.program;
+        // assign opacity
+        // assign attribute locations
+        gl.bindAttribLocation(program, 0, "pos3D");
+        gl.bindAttribLocation(program, 1, "pos2D");
+        gl.bindAttribLocation(program, 2, "rgba");
+        gl.bindAttribLocation(program, 3, "size");
+        // arrange camera uniform block
+        this.cameraBlockTotem = totems_1.CameraUniformBlockTotemCache.get(globe);
+        this.cameraBlockTotem.assignBindingPoint(program, uniformBindingPoints.camera);
+        uniformBlockManager.assignBindingPoint(this.gl, this.program);
+        this._defaultUBO = uniformBlockManager.createUBO(this.gl);
+        this._defaultUBO.update(new Map([
+            ["u_rgba", [1, 1, 1, 1]],
+            ["u_opacity", [1.0]],
+            ["u_size_multiplier", [1.0]],
+            ["u_size", [1.0]],
+            ["u_is_circle", [1.0]],
+        ]));
+    }
+    PointOnGlobeProgram.prototype.createUBO = function () {
+        var ubo = uniformBlockManager.createUBO(this.gl);
+        return ubo;
+    };
+    PointOnGlobeProgram.prototype.createVAO = function (pos3DBufferObj, pos2DBufferObj, rgbaBufferObj, sizeBufferObj) {
+        var gl = this.gl;
+        var vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        (0, attribute_loader_1.attributeLoader)(gl, pos3DBufferObj, 0, 3);
+        (0, attribute_loader_1.attributeLoader)(gl, pos2DBufferObj, 1, 2);
+        (0, attribute_loader_1.attributeLoader)(gl, rgbaBufferObj, 2, 4, { escapeValues: [-1, -1, -1, -1] });
+        (0, attribute_loader_1.attributeLoader)(gl, sizeBufferObj, 3, 1, { escapeValues: [-1] });
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+    };
+    /**
+     *
+     * @param {vertexArrayObject} vao
+     * @param {DrawRangeIndexParams} drawOptions
+     */
+    PointOnGlobeProgram.prototype.draw = function (vao, drawOptions, ubo) {
+        if (ubo === void 0) { ubo = null; }
+        var _a = this, gl = _a.gl, program = _a.program;
+        gl.useProgram(program);
+        gl.bindVertexArray(vao);
+        this.cameraBlockTotem.bind(uniformBindingPoints.camera);
+        ubo = ubo || this._defaultUBO;
+        ubo.bind();
+        (0, methods_1.drawArrays)(gl, gl.POINTS, drawOptions);
+        ubo.unbind();
+        this.cameraBlockTotem.unbind(uniformBindingPoints.camera);
+        gl.bindVertexArray(null);
+    };
+    PointOnGlobeProgram.prototype.free = function () {
+        if (this._isFreed)
+            return;
+        var _a = this, gl = _a.gl, globe = _a.globe;
+        totems_1.CameraUniformBlockTotemCache.release(globe);
+        gl.deleteProgram(this.program);
+        this._isFreed = true;
+    };
+    return PointOnGlobeProgram;
+}());
+var PickableRendererProgramCache = Object.freeze({
+    get: function (globe) { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, PointOnGlobeProgram); },
+    release: function (globe) { return programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, PointOnGlobeProgram); }
+});
+exports.PickableRendererProgramCache = PickableRendererProgramCache;