@pirireis/webglobeplugins 0.9.9 → 0.9.10

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CirclePadding3DCache = void 0;
+const webglobjectbuilders_1 = require("../../util/webglobjectbuilders");
+const camerauniformblock_1 = require("../totems/camerauniformblock");
+const programcache_1 = require("../programcache");
+// import { vaoAttributeLoader } from "../../util/account/util";
+const attribute_loader_1 = require("../../util/gl-util/buffer/attribute-loader");
+const util_1 = require("./util");
+const 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.
+ */
+const INITIAL_EDGE_COUNT = 720;
+const vertexShaderSource = `#version 300 es
+precision highp float;
+${camerauniformblock_1.CameraUniformBlockString}
+${geometrytransformations_1.cartesian3DToGLPosition}
+${geometrytransformations_1.circleLimpFromLongLatRadCenterCartesian3D_accurate}
+
+
+in vec3 center_position3d;
+in float big_radius;
+in float small_radius;
+in vec4 color;
+
+uniform float edge_count;
+uniform float step_angle;
+uniform int z_alpha_on;
+
+out float interpolation;
+out vec4 v_color;
+void main() {
+    if( !is3D) {
+        return;
+    }
+    v_color = color;
+    if ( z_alpha_on == 1 ){
+        float z_alpha = pow(z_level * 0.75, 3.0) * distance(big_radius, small_radius) / (R * 2.0);
+        if ( z_alpha < 0.1 ) { return; }
+        v_color.a *= z_alpha;
+    }
+    int pad_phase =  gl_VertexID % 2; // 0 or 1
+    interpolation = float( gl_VertexID - pad_phase) / edge_count;
+    float angle = float( gl_VertexID - pad_phase) * step_angle;
+    vec3 position;
+    if ( pad_phase == 0 ) {
+        position = circleLimpFromLongLatRadCenterCartesian3D_accurate(center_position3d, big_radius, angle);
+    } else {
+        position = circleLimpFromLongLatRadCenterCartesian3D_accurate(center_position3d, small_radius, angle);
+    }
+    gl_Position = cartesian3DToGLPosition(position);
+
+    gl_PointSize = 5.0;
+}`;
+const fragmentShaderSource = `#version 300 es
+${geometrytransformations_1.POLE}
+precision highp float;
+uniform float opacity;
+in vec4 v_color;
+in float interpolation;
+in vec2 v_limp;
+out vec4 color;
+void main() {
+    color = v_color;
+    color.a *= opacity;
+}
+`;
+class Logic {
+    constructor(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);
+        const { gl, program } = this;
+        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
+            const 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);
+        const cameraBlockLocation = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        gl.uniformBlockBinding(program, cameraBlockLocation, this.cameraBindingPoint);
+    }
+    createVAO(center3dObj, bigRadiusObj, smallRadiusObj, colorObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        const divisor = 1;
+        gl.bindVertexArray(vao);
+        (0, attribute_loader_1.attributeLoader)(gl, center3dObj, 0, 3, { divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, bigRadiusObj, 1, 1, { divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, smallRadiusObj, 2, 1, { divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, colorObj, 3, 4, { divisor });
+        gl.bindVertexArray(null);
+        return vao;
+    }
+    draw(vao, length, edgeCount, stepAngle, opacity, zAlphaMode = util_1.Z_ALPHA_MODE.ON) {
+        const { gl, program, cameraBlockTotem, cameraBindingPoint } = this;
+        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);
+    }
+    free() {
+        if (this.isFreed)
+            return;
+        camerauniformblock_1.CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+        this.isFreed = true;
+    }
+}
+exports.CirclePadding3DCache = Object.freeze({
+    get: (globe) => programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => 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,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Z_ALPHA_MODE = exports.LinesColorInstancedFlatCache = void 0;
+const totems_1 = require("../totems");
+const geometrytransformations_1 = require("../../util/shaderfunctions/geometrytransformations");
+const programcache_1 = require("../programcache");
+const util_1 = require("../../util");
+const util_2 = require("./util");
+Object.defineProperty(exports, "Z_ALPHA_MODE", { enumerable: true, get: function () { return util_2.Z_ALPHA_MODE; } });
+const 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
+const vertexShaderSource = `#version 300 es
+precision highp float;
+${totems_1.CameraUniformBlockString}
+${geometrytransformations_1.mercatorXYToGLPosition}
+uniform float opacity;
+uniform int z_alpha_on;
+
+in vec2 posA;
+in vec2 posB;
+in vec4 color;
+
+out vec2 v_frame;
+out vec4 v_color;
+void main() {
+    
+    if ( is3D ) {
+        return;
+    }
+    float gap = max( distance(posA.x, posB.x), distance(posA.y,posB.y)); // 
+    if ( gap > 37000000.0) { return; }
+    float z_alpha;
+    if ( z_alpha_on == 1 ){ 
+        z_alpha =  pow(2.0,z_level+1.0) /  ( 10000000.0 / gap);
+        z_alpha = smoothstep(0.1,0.9, z_alpha);
+        if( z_alpha < 0.01) {return;}
+    } else {
+        z_alpha = 1.0;
+    }
+        vec2 pos;
+    if ( gl_VertexID == 0 ) {
+        pos = posA;
+        } else {
+            pos = posB;
+    }
+    v_frame = pos;
+    gl_Position = mercatorXYToGLPosition( pos );
+    v_color = color;
+    v_color.a *= z_alpha * opacity;
+    gl_PointSize = 4.0;
+}`;
+const fragmentShaderSource = `#version 300 es
+${geometrytransformations_1.POLE}
+precision highp float;
+in vec4 v_color;
+in vec2 v_frame;
+out vec4 outColor;
+void main() {
+    if ( v_frame.x < -POLE || v_frame.x > POLE || v_frame.y < -POLE || v_frame.y > POLE ){ discard; }
+    outColor = v_color;
+}`;
+class Logic {
+    constructor(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;
+        const { gl, program } = this;
+        const 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;
+            const cameraBlockBindingIndex = gl.getUniformBlockIndex(program, 'CameraUniformBlock');
+            gl.uniformBlockBinding(program, cameraBlockBindingIndex, this._cameraBindingPoint);
+        }
+        gl.useProgram(currentProgram);
+    }
+    createVAO(posAObj, posBObj, colorObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        const divisor = 1;
+        gl.bindVertexArray(vao);
+        (0, attribute_loader_1.attributeLoader)(gl, posAObj, 0, 2, { divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, posBObj, 1, 2, { divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, colorObj, 2, 4, { divisor });
+        gl.bindVertexArray(null);
+        return vao;
+    }
+    draw(vao, lineCount, opacity = 1.0, zAlphaOn = util_2.Z_ALPHA_MODE.ON) {
+        const { gl, program, _cameraBindingPoint, _cameraUniformBlock } = this;
+        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);
+    }
+    free() {
+        if (this.isFreed)
+            return;
+        const { gl, program, globe } = this;
+        totems_1.CameraUniformBlockTotemCache.release(globe);
+        gl.deleteProgram(program);
+        this.isFreed = true;
+    }
+}
+const LinesColorInstancedFlatCache = Object.freeze({
+    get: (globe) => { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic); },
+    release: (globe) => { programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic); }
+});
+exports.LinesColorInstancedFlatCache = LinesColorInstancedFlatCache;

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

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineStripProgramCache = void 0;
+const webglobjectbuilders_1 = require("../../util/webglobjectbuilders");
+require("../interface");
+const totems_1 = require("../totems");
+const geometrytransformations_js_1 = require("../../util/shaderfunctions/geometrytransformations.js");
+const programcache_1 = require("../programcache");
+const attribute_loader_1 = require("../../util/gl-util/buffer/attribute-loader");
+require("../../util/gl-util/buffer/attribute-loader");
+const manager_1 = require("../../util/gl-util/uniform-block/manager");
+require("../../util/gl-util/uniform-block/types");
+const methods_1 = require("../../util/gl-util/draw-options/methods");
+require("../../util/gl-util/draw-options/types");
+const ESCAPE_VALUE = -1;
+const uniformBindingPoints = {
+    camera: 0,
+    flexible: 1,
+};
+const one = new Float32Array([1]);
+const 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);
+const vertexShaderSource = `#version 300 es
+precision highp float;
+
+${totems_1.CameraUniformBlockString}
+${geometrytransformations_js_1.cartesian3DToGLPosition}
+${geometrytransformations_js_1.mercatorXYToGLPosition}
+
+${flexibleBlockManager.glslCode()}
+
+in vec3 position3d;
+in vec2 position2d;
+in vec4 color; 
+in float dash_length;
+in float dash_opacity;
+
+out float v_dash_length;
+out float v_dash_opacity;
+out vec4 v_color;
+
+flat out vec3 v_flat_position;
+out vec3 v_position;
+
+void main() {
+
+    v_color = ( color.r == -1.0 ) ? u_color : color;
+    v_dash_length = ( dash_length == -1.0 ) ? u_dash_length : dash_length;
+    v_dash_opacity = ( dash_opacity == -1.0 ) ? u_dash_opacity : dash_opacity;
+
+    if ( is3D ) {
+        gl_Position = cartesian3DToGLPosition( position3d );
+        v_position = position3d;
+        v_flat_position = position3d;
+    } else {
+        gl_Position = mercatorXYToGLPosition( position2d );
+        v_position = vec3( position2d, 0.0 );
+        v_flat_position = vec3( position2d, 0.0 );
+    }
+    gl_PointSize = 4.0;
+}`;
+const fragmentShaderSource = `#version 300 es
+precision highp float;
+
+uniform float opacity;
+
+in vec4 v_color;
+in float v_dash_length;
+in float v_dash_opacity;
+
+flat in vec3 v_flat_position;
+in vec3 v_position;
+
+
+out vec4 outColor;
+
+void main() {
+    outColor = v_color;
+    return;
+    float dash_length = v_dash_length;
+    float dash_opacity = v_dash_opacity;
+
+    if ( dash_length == 0.0 ) {
+        outColor = vec4( v_color.rgb, v_color.a * v_dash_opacity );
+    } else {
+        float dist = distance( v_flat_position, v_position );
+        // float alpha = mod( dist , v_dash_length * 2.0 ) / v_dash_length < 1.0 ? 1.0 : v_dash_opacity;
+        outColor = vec4( v_color.rgb,  v_color.a * opacity );
+    }
+}`;
+console.log("LineStripProgram");
+console.log(vertexShaderSource);
+console.log(fragmentShaderSource);
+class Logic {
+    constructor(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);
+        const 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);
+    }
+    createUBO(bufferReadType = "STATIC_DRAW") {
+        const ubo = flexibleBlockManager.createUBO(this.gl, bufferReadType);
+        this._ubosPublished.push(ubo);
+        return ubo;
+    }
+    createVAO(position3D, position2D, color, dashLength, dashOpacity) {
+        const { gl } = this;
+        const 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;
+    }
+    draw(vao, drawOptions, opacity = 1, flexibleUBO = null) {
+        const { gl, program, cameraBlockTotem } = this;
+        gl.useProgram(program);
+        if (opacity !== this._opacity.value) {
+            this._opacity.value = opacity;
+            this.gl.uniform1f(this._opacity.location, this._opacity.value);
+        }
+        const 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);
+    }
+    free() {
+        this._vaosPublished.forEach((vao) => this.gl.deleteVertexArray(vao));
+        this._ubosPublished.forEach((ubo) => ubo.free());
+        this.gl.deleteProgram(this.program);
+        this._defaultFlexibleUBO.free();
+        totems_1.CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+    }
+}
+exports.LineStripProgramCache = Object.freeze({
+    get: (globe) => programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic),
+});

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

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineOnGlobeCache = void 0;
+const totems_1 = require("../totems");
+const geometrytransformations_1 = require("../../util/shaderfunctions/geometrytransformations");
+const util_1 = require("../../util");
+const programcache_1 = require("../programcache");
+const attribute_loader_1 = require("../../util/gl-util/buffer/attribute-loader");
+const manager_1 = require("../../util/gl-util/uniform-block/manager");
+require("../../util/gl-util/draw-options/types");
+const methods_1 = require("../../util/gl-util/draw-options/methods");
+const GLOBE_MIDPOINT_COUNT = 30;
+const escapeValue = -1.0;
+const uniformBindingPoints = {
+    camera: 0,
+    flexible: 1
+};
+const 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);
+const vertexShader = `#version 300 es
+precision highp float;
+
+${geometrytransformations_1.R_3D}
+${totems_1.CameraUniformBlockString}
+${geometrytransformations_1.slerp}
+${geometrytransformations_1.mercatorXYToGLPosition}
+${geometrytransformations_1.cartesian3DToGLPosition}
+
+${uniformBlockManager.glslCode()}
+
+in vec2 start_position;
+in vec3 start_position3d;
+in vec2 end_position;
+in vec3 end_position3d;
+
+in float dash_ratio;
+in float dash_opacity;
+in vec4 color;
+
+out float v_dash_ratio;
+out float v_dash_opacity;
+out vec4 v_color;
+
+out vec2 v_limp;
+out float interpolation;
+
+void main() {
+    vec2 longLat;
+
+    v_color = (color.r == -1.0) ? u_color: color;
+    v_dash_ratio = (dash_ratio == -1.0) ? u_dash_ratio : dash_ratio;
+    v_dash_opacity = (dash_opacity == -1.0) ? u_dash_opacity : dash_opacity;
+
+    if (is3D) {
+        interpolation = float(gl_VertexID) / ${GLOBE_MIDPOINT_COUNT - 1}.0;
+        vec3 cartesian = slerp(start_position3d, end_position3d, interpolation);
+        gl_Position = cartesian3DToGLPosition(cartesian);
+        v_limp = vec2(0.0, 0.0);
+    } else {
+        if ( distance( start_position, end_position) > 30000000.0) { return; }
+        interpolation = float(gl_VertexID);
+        if (gl_VertexID % 2 == 0) {
+            longLat = start_position;
+        } else {
+            longLat = end_position;
+        }
+        v_limp = longLat;
+        gl_Position = mercatorXYToGLPosition(longLat);
+    }
+}
+`;
+const fragmentShader = `#version 300 es
+${geometrytransformations_1.POLE}
+precision highp float;
+
+uniform float opacity;
+
+in float interpolation;
+in vec2 v_limp;
+in vec4 v_color;
+in float v_dash_ratio;
+in float v_dash_opacity;
+
+out vec4 color;
+
+void main() {
+    if (v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE) { discard; }
+    color = v_color;
+    color.a *= opacity;
+    if ( v_dash_ratio >= 1.0 ) { return; }
+    if (interpolation > 0.95) { return; }
+    if (fract(interpolation / (2.0 * v_dash_ratio)) < 0.5) { color.a *= v_dash_opacity; }
+
+}
+`;
+class Logic {
+    constructor(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;
+        const { gl, program } = this;
+        const 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
+     */
+    draw(vao, drawOptions, opacity, flexibleUBO = null) {
+        const { gl, program, globe, cameraBlockTotem, _defaultFlexibleUBO } = this;
+        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);
+        const vertexCount = globe.api_GetCurrentGeometry() === 0 ? GLOBE_MIDPOINT_COUNT : 2;
+        const ubo = flexibleUBO || _defaultFlexibleUBO;
+        ubo.bind();
+        (0, methods_1.drawInstanced)(gl, gl.LINE_STRIP, drawOptions, vertexCount);
+        ubo.unbind();
+        gl.bindVertexArray(null);
+        cameraBlockTotem.unbind(uniformBindingPoints.camera);
+    }
+    createUBO(bufferReadType = "STATIC_DRAW") {
+        const 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;
+    }
+    createVAO(startPotision2DBufferObj, startPotision3DBufferObj, endPosition2DBufferObj, endPosition3DBufferObj, dashRatioBufferObj, dashOpacityBufferObj, colorBufferObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        const divisor = 1;
+        (0, attribute_loader_1.attributeLoader)(gl, startPotision2DBufferObj, 0, 2, { divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, startPotision3DBufferObj, 1, 3, { divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, endPosition2DBufferObj, 2, 2, { divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, endPosition3DBufferObj, 3, 3, { divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, dashRatioBufferObj, 4, 1, { divisor, escapeValues: [escapeValue] });
+        (0, attribute_loader_1.attributeLoader)(gl, dashOpacityBufferObj, 5, 1, { divisor, escapeValues: [escapeValue] });
+        (0, attribute_loader_1.attributeLoader)(gl, colorBufferObj, 6, 4, { divisor, escapeValues: [escapeValue, escapeValue, escapeValue, escapeValue] });
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this.vaosPublished.push(vao);
+        return vao;
+    }
+    free() {
+        if (this.isFreed)
+            return;
+        totems_1.CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+        this.vaosPublished.forEach(vao => this.gl.deleteVertexArray(vao));
+        this._ubosPublished.forEach(ubo => ubo.free());
+        this.isFreed = true;
+    }
+}
+exports.LineOnGlobeCache = Object.freeze({
+    get: (globe) => { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic); },
+    release: (globe) => { return programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic); }
+});