@pirireis/webglobeplugins 0.9.9 → 0.9.10

package/programs/line-on-globe/circle-accurate-flat.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EDGE_COUNT = exports.CircleCache = void 0;
+exports.centerCoords2dflatDataCreator = centerCoords2dflatDataCreator;
+exports.centerCoords2dflatDataCreatorWithRadius = centerCoords2dflatDataCreatorWithRadius;
+const webglobjectbuilders_1 = require("../../util/webglobjectbuilders");
+const camerauniformblock_1 = require("../totems/camerauniformblock");
+const programcache_1 = require("../programcache");
+const util_1 = require("../../util/account/util");
+const geometrytransformations_1 = require("../../util/shaderfunctions/geometrytransformations");
+const Pole = 20037508.34;
+/**
+* Warning:
+* Insert the points from the second index and skip 1 point as you placed 361 points
+*/
+/**
+ * Plus 1 for returning to the start point. 1 for cutting the circle into pieces.
+ */
+const EDGE_COUNT = 62;
+exports.EDGE_COUNT = EDGE_COUNT;
+const ESCAPE_VALUE = 200000000;
+const vertexShaderSource = `#version 300 es
+precision highp float;
+
+# define escape_value ${ESCAPE_VALUE}.0
+
+${camerauniformblock_1.CameraUniformBlockString}
+${geometrytransformations_1.mercatorXYToGLPosition}
+
+uniform int edge_count;
+
+
+in vec2 position2d;
+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;
+out vec2 v_limp;
+
+
+void main() {
+    if ( position2d.x == escape_value && position2d.y == escape_value){ return; }
+    interpolation = float( gl_VertexID % edge_count ) / float(edge_count);
+    if ( gl_VertexID % edge_count == 0 ) { return; } // cut on the first point.
+    if ( is3D ) {
+        return;
+        v_limp = vec2(0.0, 0.0);
+    } else {
+        v_limp = position2d;
+        gl_Position = mercatorXYToGLPosition( position2d);
+    }
+    v_dash_ratio = dash_ratio;
+    v_dash_opacity = dash_opacity;
+    v_color = color;
+    gl_PointSize = 15.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() {
+    if ( v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE ){ 
+        discard;
+        // color = vec4(0.0,0.0,0.0,0.0); 
+        // return; 
+    }
+    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._lastMercatorMode = 0;
+        this._lastEdgeCount = EDGE_COUNT;
+        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"),
+            mercator_calculation_mode: gl.getUniformLocation(program, "mercator_calculation_mode")
+        };
+        // initial uniform values
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(program);
+        gl.uniform1f(program.uniforms.opacity, 1.0);
+        gl.uniform1i(program.uniforms.edgeCount, EDGE_COUNT);
+        gl.uniform1i(program.uniforms.mercator_calculation_mode, 0);
+        gl.useProgram(currentProgram);
+        // assign attribute locations
+        gl.bindAttribLocation(program, 0, "position2d");
+        gl.bindAttribLocation(program, 1, "color");
+        gl.bindAttribLocation(program, 2, "dash_ratio");
+        gl.bindAttribLocation(program, 3, "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(centerObj, colorObj, dashRatioObj, dashOpacityObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        { // make this a function end import from account module. 
+            const { buffer, stride = 0, offset = 0 } = centerObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 0, 2, stride, offset, null);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = colorObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 1, 4, stride, offset, null);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = dashRatioObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 2, 1, stride, offset, null);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = dashOpacityObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 3, 1, stride, offset, null);
+        }
+        gl.bindVertexArray(null);
+        gl.bindVertexArray(null);
+        return vao;
+    }
+    draw(vao, length, edgeCount, opacity) {
+        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.uniform1i(program.uniforms.edgeCount, edgeCount);
+            this._lastEdgeCount = edgeCount;
+        }
+        gl.bindVertexArray(vao);
+        cameraBlockTotem.bind(cameraBindingPoint);
+        gl.drawArrays(gl.LINE_STRIP, 0, length * edgeCount);
+        // gl.drawArrays(gl.POINTS, 0, length * EDGE_COUNT)
+        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;
+    }
+}
+const CircleCache = Object.freeze({
+    get: (globe) => programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});
+exports.CircleCache = CircleCache;
+function centerCoords2dflatDataCreator(globe, centerLong, centerLat, targetLong, targetLat, { startAngleOfCircle = null, edgeCount = EDGE_COUNT, radiusOffset = 0 } = {}) {
+    const centerCoords2dflat = new Float32Array(edgeCount * 2);
+    const radius2d = globe.Math.GetDist2D(centerLong, centerLat, targetLong, targetLat) + radiusOffset;
+    let angle;
+    if (startAngleOfCircle === null) {
+        angle = globe.Math.GetAzimuthAngle(centerLong, centerLat, targetLong, targetLat);
+    }
+    else {
+        angle = startAngleOfCircle;
+    }
+    const pointsLongLat = globe.Math.GetEllipseGeo(centerLong, centerLat, radius2d, radius2d, angle, 360 / (edgeCount - 2));
+    let lastlg = pointsLongLat[0].long;
+    let lastlt = pointsLongLat[0].lat;
+    for (let i = 1; i < edgeCount; i++) {
+        const { long: lg, lat: lt } = pointsLongLat[i - 1];
+        if (manhattanDistance(lastlg, lastlt, lg, lt) < 170) {
+            centerCoords2dflat.set(globe.api_GetMercator2DPoint(lg, lt), i * 2);
+        }
+        else {
+            centerCoords2dflat.set([NaN, NaN], i * 2);
+        }
+        lastlg = lg;
+        lastlt = lt;
+    }
+    return centerCoords2dflat;
+}
+function centerCoords2dflatDataCreatorWithRadius(globe, centerLong, centerLat, radius2d, { startAngleOfCircle = null, edgeCount = EDGE_COUNT } = {}) {
+    const centerCoords2dflat = new Float32Array(edgeCount * 2);
+    const pointsLongLat = globe.Math.GetEllipseGeo(centerLong, centerLat, radius2d, radius2d, 0, 360 / (edgeCount - 2));
+    let { long: lastlg, lat: lastlt } = pointsLongLat[0];
+    for (let i = 1; i < edgeCount; i++) {
+        const { long: lg, lat: lt } = pointsLongLat[i - 1];
+        if (manhattanDistance(lastlg, lastlt, lg, lt) < 170) {
+            centerCoords2dflat.set(globe.api_GetMercator2DPoint(lg, lt), i * 2);
+        }
+        else {
+            centerCoords2dflat.set([NaN, NaN], i * 2);
+        }
+        lastlg = lg;
+        lastlt = lt;
+    }
+    return centerCoords2dflat;
+}
+function manhattanDistance(x1, y1, x2, y2) {
+    return Math.max(Math.abs(x1 - x2), Math.abs(y1 - y2));
+}

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

@@ -0,0 +1,178 @@
+"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");
+const util_1 = require("../../util/account/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 EDGE_COUNT_ON_SPHERE = 360;
+const vertexShaderSource = `#version 300 es
+precision highp float;
+${camerauniformblock_1.CameraUniformBlockString}
+${geometrytransformations_1.longLatRadToMercator}
+${geometrytransformations_1.longLatRadToCartesian3D}
+${geometrytransformations_1.cartesian3DToGLPosition}
+${geometrytransformations_1.mercatorXYToGLPosition}
+${geometrytransformations_1.realDistanceOnSphereR1}
+${geometrytransformations_1.circleLimpFromLongLatRadCenterCartesian3D_accurate}
+${geometrytransformations_1.circleLimpFromLongLatRadCenterMercatorCompass_accurate}
+${geometrytransformations_1.circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate}
+
+uniform float edge_count;
+
+in vec2 center_position;
+in vec3 center_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;
+out vec2 v_limp;
+void main() {
+    interpolation = float( gl_VertexID ) / ${EDGE_COUNT_ON_SPHERE}.0;
+    float angle = PI * 2.0 * interpolation;
+    if ( is3D ) {
+
+        vec3 position = circleLimpFromLongLatRadCenterCartesian3D_accurate(center_position3d, radius, angle);
+    
+        gl_Position = cartesian3DToGLPosition(position);
+        v_limp = vec2(0.0, 0.0);
+    } else {
+        vec2 position;  
+        if ( radius < 0.0) {
+            float cosine1 = cos(asin(tanh(center_position.y / 6378137.0)));
+            position = circleLimpFromLongLatRadCenterMercatorCompass_accurate(center_position, radius /  cosine1 , angle);
+        } else {
+            position = circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate( center_position, radius, angle);
+        }
+        v_limp = position;
+        gl_Position = mercatorXYToGLPosition( position);
+
+    }
+    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() {
+    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 = 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_position");
+            gl.bindAttribLocation(program, 1, "center_position3d");
+            gl.bindAttribLocation(program, 2, "radius");
+            gl.bindAttribLocation(program, 3, "color");
+            gl.bindAttribLocation(program, 4, "dash_ratio");
+            gl.bindAttribLocation(program, 5, "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(centerObj, center3dObj, radiusObj, colorObj, dashRatioObj, dashOpacityObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        const divisor = 1;
+        gl.bindVertexArray(vao);
+        { // make this a function end import from account module. 
+            const { buffer, stride = 0, offset = 0 } = centerObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 0, 2, stride, offset, divisor);
+        }
+        { // make this a function end import from account module. 
+            const { buffer, stride = 0, offset = 0 } = center3dObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 1, 3, stride, offset, divisor);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = radiusObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 2, 1, stride, offset, divisor);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = colorObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 3, 4, stride, offset, divisor);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = dashRatioObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 4, 1, stride, offset, divisor);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = dashOpacityObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 5, 1, stride, offset, 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)
+});

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

@@ -0,0 +1,167 @@
+"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");
+const util_1 = require("../../util/account/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 EDGE_COUNT_ON_SPHERE = 360;
+const vertexShaderSource = `#version 300 es
+precision highp float;
+${camerauniformblock_1.CameraUniformBlockString}
+${geometrytransformations_1.longLatRadToMercator}
+${geometrytransformations_1.longLatRadToCartesian3D}
+${geometrytransformations_1.cartesian3DToGLPosition}
+${geometrytransformations_1.mercatorXYToGLPosition}
+${geometrytransformations_1.realDistanceOnSphereR1}
+${geometrytransformations_1.circleLimpFromLongLatRadCenterCartesian3D}
+${geometrytransformations_1.circleLimpFromLongLatRadCenterMercatorCompass}
+${geometrytransformations_1.circleLimpFromLongLatRadCenterMercatorRealDistance}
+
+uniform float edge_count;
+
+in vec2 center_position;
+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;
+out vec2 v_limp;
+void main() {
+    interpolation = float( gl_VertexID ) / ${EDGE_COUNT_ON_SPHERE}.0;
+    float angle = PI * 2.0 * interpolation;
+    if ( is3D ) {
+        vec3 position = circleLimpFromLongLatRadCenterCartesian3D( center_position, radius, angle);
+        gl_Position = cartesian3DToGLPosition(position);
+        v_limp = vec2(0.0, 0.0);
+    } else {
+        vec2 position;
+        if (radius < 1400.0) {
+            position = circleLimpFromLongLatRadCenterMercatorCompass( center_position, radius/ cos(center_position.y), angle);
+        } else {
+           position = circleLimpFromLongLatRadCenterMercatorRealDistance( center_position, radius, angle);
+        }
+        v_limp = position;
+        gl_Position = mercatorXYToGLPosition( position);
+
+    }
+    v_dash_ratio = dash_ratio;
+    v_dash_opacity = dash_opacity;
+    v_color = color;
+
+}`;
+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 = 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_position");
+            gl.bindAttribLocation(program, 1, "radius");
+            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(centerObj, radiusObj, colorObj, dashRatioObj, dashOpacityObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        const divisor = 1;
+        gl.bindVertexArray(vao);
+        { // make this a function end import from account module. 
+            const { buffer, stride = 0, offset = 0 } = centerObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 0, 2, stride, offset, divisor);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = radiusObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 1, 1, stride, offset, divisor);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = colorObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 2, 4, stride, offset, divisor);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = dashRatioObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 3, 1, stride, offset, divisor);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = dashOpacityObj;
+            (0, util_1.vaoAttributeLoader)(gl, buffer, 4, 1, stride, offset, 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);
+        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)
+});