@pirireis/webglobeplugins 0.9.9 → 0.9.10

package/programs/globeshell/wiggle/object.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const programcache_1 = require("../../programcache");
+const logic_1 = __importDefault(require("./logic"));
+class GlobeShell {
+    constructor(gl, globe, { minLon = -180, maxLon = 180, minLat = -90, maxLat = 90, height = 0, u_opacity = 1, wiggleInKM = 0, wiggleSpeed = 0,
+    // eastWestTied, Not implemented yet
+     } = {}) {
+        this.gl = gl;
+        this.globe = globe;
+        this.program = programcache_1.globeProgramCache.getProgram(globe, logic_1.default);
+        this.shellBlockManager = this.program.getShellBlockBufferManager();
+        this.update = this.shellBlockManager.update.bind(this.shellBlockManager);
+        this.innerTime = 0;
+        this.setBBox({ minLon, maxLon, minLat, maxLat });
+        this.setOpacity(u_opacity);
+        this.setHeight(height);
+        this.setWiggle({ wiggleSpeed, wiggleInKM });
+    }
+    setTexture(texture) {
+        this.texture = texture;
+        this.globe.DrawRender();
+    }
+    setHeight(height) {
+        this.shellBlockManager.update({ height });
+        this.globe.DrawRender();
+    }
+    setOpacity(opacity) {
+        this.shellBlockManager.update({ opacity });
+        this.globe.DrawRender();
+    }
+    setBBox({ minLon = -180, maxLon = 180, minLat = -90, maxLat = 90 } = {}) {
+        this.bbox = { minLon, maxLon, minLat, maxLat };
+        // x
+        const horOffset = (minLon) * Math.PI / 180;
+        const horSize = (maxLon - minLon) * Math.PI / 180;
+        // y
+        const vertOffset = (90 - maxLat) * Math.PI / 180;
+        const vertSize = (maxLat - minLat) * Math.PI / 180;
+        const offset_rad = new Float32Array([horOffset, vertOffset]);
+        const size_rad = new Float32Array([horSize, vertSize]);
+        this.shellBlockManager.update({ gridSizeRad: size_rad, gridOffsetRad: offset_rad });
+        this.globe.DrawRender();
+    }
+    setWiggle({ wiggleSpeed = null, wiggleInKM = null }) {
+        if (wiggleInKM !== null)
+            this.wiggleInKM = wiggleInKM;
+        if (wiggleSpeed !== null)
+            this.wiggleSpeed = wiggleSpeed;
+        this.shellBlockManager.update({ wiggleInKM });
+    }
+    /**
+     *
+     * @param {*} program  modelView, projection, translate, mapWH, scrWH, should be set before calling this function
+     */
+    draw() {
+        this.program.draw(this.texture, this.shellBlockManager);
+        if (this.wiggleInKM > 0 && this.wiggleSpeed > 0) {
+            this.innerTime += this.wiggleSpeed;
+            this.shellBlockManager.update({ innerTime: this.innerTime });
+            this.globe.DrawRender();
+        }
+    }
+    free() {
+        programcache_1.globeProgramCache.releaseProgram(this.globe, logic_1.default);
+        this.shellBlockManager.free();
+    }
+}
+exports.default = GlobeShell;

package/programs/helpers/blender/index.js

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

package/programs/helpers/blender/program.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+/**
+ * Blends two float32textures with given ratio.
+ */
+const vertexShader = `#version 300 es
+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 fragmentShader = `#version 300 es
+uniform sampler2D u_texture0;
+uniform sampler2D u_texture1;
+uniform float u_ratio;
+in v_texCoord;
+out vec4 outColor;
+void main() {
+    vec4 color0 = texture(u_texture0, v_texCoord);
+    vec4 color1 = texture(u_texture1, v_texCoord);
+    outColor = mix(color0, color1, u_ratio);
+}
+`;
+class BlenderProgram {
+    constructor(gl) {
+        this.gl = gl;
+        this.programWrapper = this._createProgramWrapper();
+    }
+    _craeteProgramWrapper() {
+        const gl = this.gl;
+        const program = (0, util_1.createProgram)(gl, vertexShader, fragmentShader);
+        this.vao = gl.createVertexArray();
+        gl.bindVertexArray(this.vao);
+        this._buffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+            -1, -1,
+            1, -1,
+            -1, 1,
+            -1, 1,
+            1, -1,
+            1, 1,
+        ]), gl.STATIC_DRAW);
+        gl.enableVertexAttribArray(0);
+        gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return { program, uniforms: { u_texture0: gl.getUniformLocation(program, 'u_texture0'), u_texture1: gl.getUniformLocation(program, 'u_texture1'), u_ratio: gl.getUniformLocation(program, 'u_ratio') } };
+    }
+    draw(ratio, texture0, texture1) {
+        const gl = this.gl;
+        gl.useProgram(this.programWrapper.program);
+        gl.bindVertexArray(this.vao);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, texture1);
+        gl.uniform1i(this.programWrapper.uniforms.u_texture1, 1);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, texture0);
+        gl.uniform1i(this.programWrapper.uniforms.u_texture0, 0);
+        gl.uniform1f(this.programWrapper.uniforms.u_ratio, ratio);
+        gl.drawArrays(gl.TRIANGLES, 0, 6);
+        gl.bindVertexArray(null);
+    }
+    createFloat32Texture(width, height) {
+        const gl = this.gl;
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.R32F, width, height, 0, gl.RED, gl.FLOAT, null);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        return texture;
+    }
+}
+exports.default = BlenderProgram;

package/programs/helpers/fadeaway/index.js

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

package/programs/helpers/fadeaway/logic.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../../../util");
+const vertexShaderSource = `#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 + vec2(0.5);
+}
+`;
+const fragmentShaderSource = `#version 300 es
+precision highp float;
+uniform float opacity;
+uniform sampler2D u_texture;
+in vec2 v_texCoord;
+out vec4 outColor;
+void main() {
+
+    vec4 color = texture(u_texture, v_texCoord);
+    if (color.a <= 0.2) {
+        outColor = vec4(0.0);
+        return;
+    }
+    outColor = vec4(color.rgb, color.a * opacity);
+}
+`;
+class FadeAwayProgram {
+    constructor(gl) {
+        this.gl = gl;
+        this.program = (0, util_1.createProgram)(gl, vertexShaderSource, fragmentShaderSource);
+        this.vao = gl.createVertexArray();
+        gl.bindVertexArray(this.vao);
+        this._buffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+            -1, -1,
+            1, -1,
+            -1, 1,
+            -1, 1,
+            1, -1,
+            1, 1,
+        ]), gl.STATIC_DRAW);
+        gl.enableVertexAttribArray(0);
+        gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this.uniforms = {
+            u_texture: gl.getUniformLocation(this.program, 'u_texture'),
+            opacity: gl.getUniformLocation(this.program, 'opacity')
+        };
+    }
+    draw(texture, opacity) {
+        const { gl, vao, uniforms, program } = this;
+        gl.useProgram(program);
+        gl.bindVertexArray(vao);
+        gl.uniform1f(uniforms.opacity, opacity);
+        gl.uniform1i(uniforms.u_texture, 0);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.drawArrays(gl.TRIANGLES, 0, 6);
+        gl.bindVertexArray(null);
+    }
+    free() {
+        const { gl, vao, _buffer, program } = this;
+        gl.deleteVertexArray(vao);
+        gl.deleteProgram(program);
+        gl.deleteBuffer(_buffer);
+    }
+}
+exports.default = FadeAwayProgram;

package/programs/helpers/fadeaway/object.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const programcache_1 = require("../../programcache");
+const logic_1 = __importDefault(require("./logic"));
+class FadeAway {
+    constructor(gl) {
+        this.gl = gl;
+        this.program = programcache_1.glProgramCache.getProgram(gl, logic_1.default);
+    }
+    draw(sourceTexture, opacity) {
+        this.program.draw(sourceTexture, opacity);
+    }
+    free() {
+        programcache_1.glProgramCache.releaseProgram(logic_1.default);
+    }
+}
+exports.default = FadeAway;

package/programs/helpers/index.js

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

package/programs/index.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rings = exports.FadeAway = exports.vectorfield = exports.noRegisterGlobeProgramCache = exports.globeProgramCache = exports.glProgramCache = exports.CameraUniformBlockString = exports.CameraUniformBlockTotem = exports.ArrowField = exports.GlobeShellWiggle = exports.Float2LegendWithRatio = void 0;
+const float2legendwithratio_1 = require("./float2legendwithratio");
+Object.defineProperty(exports, "Float2LegendWithRatio", { enumerable: true, get: function () { return float2legendwithratio_1.Float2LegendWithRatio; } });
+const wiggle_1 = require("./globeshell/wiggle");
+Object.defineProperty(exports, "GlobeShellWiggle", { enumerable: true, get: function () { return wiggle_1.GlobeShellWiggle; } });
+const index_1 = require("./totems/index");
+Object.defineProperty(exports, "CameraUniformBlockTotem", { enumerable: true, get: function () { return index_1.CameraUniformBlockTotem; } });
+Object.defineProperty(exports, "CameraUniformBlockString", { enumerable: true, get: function () { return index_1.CameraUniformBlockString; } });
+const arrowfield_1 = __importDefault(require("./arrowfield"));
+exports.ArrowField = arrowfield_1.default;
+const programcache_1 = require("./programcache");
+Object.defineProperty(exports, "glProgramCache", { enumerable: true, get: function () { return programcache_1.glProgramCache; } });
+Object.defineProperty(exports, "globeProgramCache", { enumerable: true, get: function () { return programcache_1.globeProgramCache; } });
+Object.defineProperty(exports, "noRegisterGlobeProgramCache", { enumerable: true, get: function () { return programcache_1.noRegisterGlobeProgramCache; } });
+const vectorfield = __importStar(require("./vectorfields"));
+exports.vectorfield = vectorfield;
+const helpers_1 = require("./helpers");
+Object.defineProperty(exports, "FadeAway", { enumerable: true, get: function () { return helpers_1.FadeAway; } });
+const rings = __importStar(require("./rings"));
+exports.rings = rings;

package/programs/interface.js

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

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

@@ -0,0 +1,176 @@
+"use strict";
+// angle radius, rgba, dashRatio, rgbaMode
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngledLineProgramCache = void 0;
+const util_1 = require("../../util");
+const totems_1 = require("../totems");
+const geometrytransformations_1 = require("../../util/shaderfunctions/geometrytransformations");
+const programcache_1 = require("../programcache");
+const EDGE_COUNT_ON_SPHERE = 50;
+const vertexShaderSource = `#version 300 es
+precision highp float;
+
+${totems_1.CameraUniformBlockString}
+${geometrytransformations_1.longLatRadToMercator}
+${geometrytransformations_1.longLatRadToCartesian3D}
+${geometrytransformations_1.cartesian3DToGLPosition}
+${geometrytransformations_1.mercatorXYToGLPosition}
+${geometrytransformations_1.circleLimpFromLongLatRadCenterCartesian3D}
+${geometrytransformations_1.circleLimpFromLongLatRadCenterMercatorCompass}
+${geometrytransformations_1.circleLimpFromLongLatRadCenterMercatorRealDistance}
+
+in vec2 center_point;
+in float angle;
+in float radius;
+in vec4 rgba;
+in float dash_ratio;
+in float dash_opacity;
+
+out vec4 v_color;
+out float v_dash_ratio;
+out float interpolation;
+out float v_dash_opacity;
+out vec2 v_limp;
+// TODO: Draw World Boundaries 
+void main() {
+    if ( is3D ) {
+        interpolation = float( gl_VertexID ) / ${EDGE_COUNT_ON_SPHERE - 1}.0;
+        float radius_ = radius* interpolation;
+        vec3 position = circleLimpFromLongLatRadCenterCartesian3D( center_point, radius_, angle);
+        gl_Position = cartesian3DToGLPosition( position);
+        v_limp = vec2(0.0, 0.0);
+    } else {
+        interpolation = float( gl_VertexID );
+        float radius_ = radius * interpolation;
+        vec2 position = circleLimpFromLongLatRadCenterMercatorRealDistance( center_point, radius_, angle);
+        v_limp = position;
+        gl_Position = mercatorXYToGLPosition( position);
+    }
+    v_dash_opacity = dash_opacity;
+    v_color = rgba;
+    v_dash_ratio = dash_ratio;
+}`;
+const fragmentShaderSource = `#version 300 es
+${geometrytransformations_1.POLE}
+precision highp float;
+
+uniform float opacity;
+in vec4 v_color;
+in float v_dash_ratio;
+in float v_dash_opacity;
+in float interpolation;
+in vec2 v_limp;
+out vec4 color;
+
+void main() {
+    if ( v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE ){ color = vec4(0.0,0.0,0.0,0.0); return; }
+    color = vec4(v_color.rgb, v_color.a * opacity);
+    if (fract(interpolation / (2.0 * v_dash_ratio)) < 0.5 ) {
+        color.a *= v_dash_opacity;
+    }   
+}`;
+class Logic {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = (0, util_1.createProgram)(this.gl, vertexShaderSource, fragmentShaderSource);
+        this._lastOpacity = 1;
+        const { gl, program } = this;
+        { // assign attribute locations
+            gl.bindAttribLocation(program, 0, "center_point");
+            gl.bindAttribLocation(program, 1, "angle");
+            gl.bindAttribLocation(program, 2, "radius");
+            gl.bindAttribLocation(program, 3, "rgba");
+            gl.bindAttribLocation(program, 4, "dash_ratio");
+            gl.bindAttribLocation(program, 5, "dash_opacity");
+        }
+        {
+            this._opacityLocation = gl.getUniformLocation(program, "opacity");
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(this._opacityLocation, this._lastOpacity);
+            gl.useProgram(currentProgram);
+        }
+        this.cameraBlockBindingPoint = 0;
+        const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        this.cameraBlockTotem = totems_1.CameraUniformBlockTotemCache.get(globe);
+        gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
+    }
+    draw(vao, length, opacity) {
+        const { gl, program, globe, cameraBlockTotem, cameraBlockBindingPoint } = this;
+        gl.useProgram(program);
+        if (opacity !== this._lastOpacity) {
+            gl.uniform1f(this._opacityLocation, opacity);
+            this._lastOpacity = opacity;
+        }
+        const drawCount = globe.api_GetCurrentGeometry() === 0 ? EDGE_COUNT_ON_SPHERE : 2;
+        gl.bindVertexArray(vao);
+        cameraBlockTotem.bind(cameraBlockBindingPoint);
+        // gl.disable(gl.DEPTH_TEST);
+        gl.drawArraysInstanced(gl.LINE_STRIP, 0, drawCount, length);
+        gl.bindVertexArray(null);
+        cameraBlockTotem.unbind(cameraBlockBindingPoint);
+        // gl.enable(gl.DEPTH_TEST);
+    }
+    createVAO(centerCoords, angle, radius, rgba, dashRatio, dashOpacity) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        {
+            const { buffer, stride = 0, offset = 0 } = centerCoords;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(0);
+            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(0, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = angle;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(1);
+            gl.vertexAttribPointer(1, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(1, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = radius;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(2);
+            gl.vertexAttribPointer(2, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(2, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = rgba;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(3);
+            gl.vertexAttribPointer(3, 4, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(3, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = dashRatio;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(4);
+            gl.vertexAttribPointer(4, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(4, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = dashOpacity;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(5);
+            gl.vertexAttribPointer(5, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(5, 1);
+        }
+        gl.bindVertexArray(null);
+        return vao;
+    }
+    free() {
+        if (this.isFreed)
+            return;
+        totems_1.CameraUniformBlockTotemCache.release(this.globe);
+        this.cameraBlockTotem = null;
+        this.gl.deleteProgram(this.program);
+        this.isFreed = true;
+    }
+}
+exports.AngledLineProgramCache = Object.freeze({
+    get: (globe) => { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic); },
+    release: (globe) => { return programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic); }
+});

package/programs/line-on-globe/circle-accurate-3d.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircleCache = 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 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 EDGE_COUNT_ON_SPHERE = 360;
+//${circleLimpFromLongLatRadCenterCartesian3D_accurate}
+const vertexShaderSource = `#version 300 es
+precision highp float;
+${geometrytransformations_1.PI}
+${camerauniformblock_1.CameraUniformBlockString}
+${geometrytransformations_1.cartesian3DToGLPosition}
+${geometrytransformations_1.circleOnSphere}
+
+uniform float edge_count;
+
+in vec3 center_position3d;
+in vec3 target_position3d;
+// in float radius;
+in vec4 color;
+in float dash_ratio;
+in float dash_opacity;
+
+out float interpolation;
+out vec4 v_color;
+out float v_dash_ratio;
+out float v_dash_opacity;
+void main() {
+    interpolation = float( gl_VertexID ) / ${EDGE_COUNT_ON_SPHERE}.0;
+    if ( is3D ) {
+        float angle = PI * 2.0 * interpolation;
+        vec3 position = circleOnSphere(center_position3d, target_position3d, angle);
+        gl_Position = cartesian3DToGLPosition(position);
+    } else {
+        return;
+    }
+    v_dash_ratio = dash_ratio;
+    v_dash_opacity = dash_opacity;
+    v_color = color;
+    gl_PointSize = 3.0;
+}`;
+const fragmentShaderSource = `#version 300 es
+${geometrytransformations_1.POLE}
+precision highp float;
+uniform float opacity;
+in vec4 v_color;
+in float v_dash_ratio;
+in float v_dash_opacity;
+in float interpolation;
+in vec2 v_limp;
+out vec4 color;
+void main() {
+    color = v_color;
+    color.a *= opacity;
+    if ( v_dash_ratio == 1.0 || v_dash_ratio == 0.0 ) return;
+    if (fract(interpolation / (2.0 * v_dash_ratio)) < 0.5 ) {
+        color.a *= v_dash_opacity;
+    }   
+}
+`;
+class Logic {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._lastOpacity = 1.0;
+        this.program = (0, webglobjectbuilders_1.createProgram)(this.gl, vertexShaderSource, fragmentShaderSource);
+        const { gl, program } = this;
+        this.program.uniforms = {
+            opacity: gl.getUniformLocation(program, "opacity")
+        };
+        { // initial uniform values
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(program.uniforms.opacity, 1.0);
+            gl.useProgram(currentProgram);
+        }
+        { // assign attribute locations
+            gl.bindAttribLocation(program, 0, "center_position3d");
+            gl.bindAttribLocation(program, 1, "target_position3d");
+            gl.bindAttribLocation(program, 2, "color");
+            gl.bindAttribLocation(program, 3, "dash_ratio");
+            gl.bindAttribLocation(program, 4, "dash_opacity");
+        }
+        this.cameraBindingPoint = 0;
+        this.cameraBlockTotem = camerauniformblock_1.CameraUniformBlockTotemCache.get(globe);
+        const cameraBlockLocation = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        gl.uniformBlockBinding(program, cameraBlockLocation, this.cameraBindingPoint);
+    }
+    createVAO(center3dObj, target3dObj, colorObj, dashRatioObj, dashOpacityObj) {
+        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, target3dObj, 1, 3, { divisor });
+        // attributeLoader(gl, radiusObj, 1, 1, { divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, colorObj, 2, 4, { divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, dashRatioObj, 3, 1, { divisor });
+        (0, attribute_loader_1.attributeLoader)(gl, dashOpacityObj, 4, 1, { divisor });
+        gl.bindVertexArray(null);
+        gl.bindVertexArray(null);
+        return vao;
+    }
+    draw(vao, length, opacity) {
+        const { gl, program, cameraBlockTotem, cameraBindingPoint } = this;
+        gl.useProgram(program);
+        if (this._lastOpacity !== opacity) {
+            gl.uniform1f(program.uniforms.opacity, opacity);
+            this._lastOpacity = opacity;
+        }
+        gl.bindVertexArray(vao);
+        cameraBlockTotem.bind(cameraBindingPoint);
+        gl.drawArraysInstanced(gl.LINE_STRIP, 0, EDGE_COUNT_ON_SPHERE + 1, length);
+        // gl.drawArraysInstanced(gl.POINTS, 0, EDGE_COUNT_ON_SPHERE + 1, 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.CircleCache = Object.freeze({
+    get: (globe) => programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});