@pirireis/webglobeplugins 0.13.0-alpha → 0.14.0-alpha

package/semiplugins/shape-on-terrain/derived/padding-plugin.js

@@ -0,0 +1,96 @@
+import { ArcOnTerrainPlugin } from "../arc-plugin";
+const EDGE_COUNT = 5;
+const paddingKeys = (padding) => {
+    const stepCount = padding.coverAngle / padding.stepAngle;
+    const keys = new Array(Math.ceil(stepCount));
+    for (let i = 0; i < stepCount; i++) {
+        keys[i] = padding.key + i;
+    }
+    if (keys.length > stepCount) {
+        keys[keys.length - 1] = padding.key + stepCount;
+    }
+    return keys;
+};
+const adapterPadding2Arc = (globe, padding) => {
+    const stepCount = padding.coverAngle / padding.stepAngle;
+    const result = new Array(Math.ceil(stepCount));
+    const fill = (i, angle) => {
+        const startPoint = globe.Math.FindPointByPolar(padding.center[0], padding.center[1], padding.outerRadius, angle);
+        const endPoint = globe.Math.FindPointByPolar(padding.center[0], padding.center[1], padding.innerRadius, angle);
+        result[i] = {
+            key: padding.key + i,
+            start: [startPoint.long, startPoint.lat],
+            end: [endPoint.long, endPoint.lat],
+            color: padding.color,
+            height: padding.height,
+        };
+    };
+    for (let i = 0; i < stepCount; i++) {
+        const angle = padding.startAngle + i * padding.stepAngle;
+        fill(i, angle);
+    }
+    if (result.length > stepCount) {
+        const i = result.length - 1;
+        const angle = padding.startAngle + padding.coverAngle;
+        fill(i, angle);
+    }
+    return result;
+};
+export const chargerAdaptor = (chargerInput, plugin, padding) => {
+};
+export class PaddingPlugin {
+    id;
+    arcPlugin;
+    _memory = new Map();
+    isFreed = false;
+    constructor(id) {
+        this.id = id;
+        this.arcPlugin = new ArcOnTerrainPlugin(id, {
+            cameraAttractionIsOn: false,
+            vertexCount: EDGE_COUNT,
+        });
+    }
+    insertBulk(items, globe) {
+        for (const padding of items) {
+            this.__delete(padding.key);
+            this._memory.set(padding.key, padding);
+        }
+        const arcInputs = items.flatMap(padding => adapterPadding2Arc(globe, padding));
+        this.arcPlugin.insertBulk(arcInputs);
+    }
+    deleteBulk(keys) {
+        const arcKeys = keys.flatMap(key => paddingKeys({ key, center: [0, 0], outerRadius: 0, innerRadius: 0, startAngle: 0, coverAngle: 0, stepAngle: 0, color: [0, 0, 0, 1] }));
+        this.arcPlugin.deleteBulk(arcKeys);
+    }
+    updateColor(key, color) {
+        // TODO: get all padding keys and update all of them
+        if (!this._memory.has(key)) {
+            console.warn(`Padding with key ${key} does not exist.`);
+            return;
+        }
+        const keys = paddingKeys(this._memory.get(key));
+        for (let i = 0; i < keys.length; i++) {
+            this.arcPlugin.updateColor(keys[i], color);
+        }
+    }
+    __delete(key) {
+        const padding = this._memory.get(key);
+        if (padding) {
+            const keys = paddingKeys(padding);
+            this.arcPlugin.deleteBulk(keys);
+            this._memory.delete(key);
+        }
+    }
+    init(globe, gl) {
+        this.arcPlugin.init(globe, gl);
+    }
+    draw3D() {
+        this.arcPlugin.draw3D();
+    }
+    free() {
+        if (this.isFreed)
+            return;
+        this.isFreed = true;
+        this.arcPlugin.free();
+    }
+}

package/semiplugins/type.js

@@ -0,0 +1 @@
+export {};

package/types.js

@@ -1,12 +1 @@
-/**
- * @typedef DrawRange
- * @type {Object}
- * @property {int} first
- * @property {int} count
- *
- * @typedef DrawRangeIndexParamsClient
- * @type {Object}
- * @property {null|DrawRange} drawRange
- * @property {null|Int32List} indexes
- */
 export {};

package/util/account/create-buffermap-orchastration.js

@@ -0,0 +1,39 @@
+// IN construction
+import { BufferManager } from "./single-attribute-buffer-management/buffer-manager";
+import { BufferOrchestrator } from "./single-attribute-buffer-management/buffer-orchestrator";
+export class BufferMapOrchestrator {
+    gl;
+    bufferManagersMap;
+    bufferOrchestrator;
+    constructor(gl, bufferDetailsMap, initialCapacity = 10) {
+        this.gl = gl;
+        this.bufferManagersMap = new Map();
+        this.bufferOrchestrator = new BufferOrchestrator({ capacity: 10 });
+        for (const [key, details] of bufferDetailsMap) {
+            const { itemSize, bufferType, adaptor } = details;
+            const bufferManager = new BufferManager(gl, itemSize, { bufferType, initialCapacity });
+            this.bufferManagersMap.set(key, { bufferManager, adaptor });
+        }
+    }
+    insertBulk(items) {
+        // @ts-ignore
+        this.bufferOrchestrator.insertBulk(items, this.bufferManagersMap);
+    }
+    updateBulk(items, bufferKeys = []) {
+        // @ts-ignore
+        this.bufferOrchestrator.updateBulk(items, this.bufferManagersMap, bufferKeys);
+    }
+    deleteBulk(keys) {
+        // @ts-ignore
+        this.bufferOrchestrator.deleteBulk(keys, this.bufferManagersMap);
+    }
+    resetWithCapacity(capacity) {
+        this.bufferOrchestrator.resetWithCapacity(this.bufferManagersMap, capacity);
+    }
+    free() {
+        for (const [key, { bufferManager }] of this.bufferManagersMap) {
+            bufferManager.free();
+        }
+        this.bufferManagersMap.clear();
+    }
+}

package/util/account/single-attribute-buffer-management/buffer-orchestrator.js

@@ -19,7 +19,7 @@ export class BufferOrchestrator {
         this.tombstoneOffsets = [];
         this._length = 0;
     }
-    insertBulk(items, bufferManagersMap) {
+    insertBulk(items, bufferManagersMap, bufferKeys = null) {
         this.ensureSpace(items.length, bufferManagersMap);
         const { offsetMap } = this;
         const offsets = [];
@@ -29,8 +29,19 @@ export class BufferOrchestrator {
             offsetMap.set(item.key, offset);
             offsets.push(offset);
         }
-        for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
-            bufferManager.insertBulk(items.map(adaptor), offsets);
+        if (bufferKeys) {
+            for (const key of bufferKeys) {
+                const bufferManagerComp = bufferManagersMap.get(key);
+                if (bufferManagerComp === undefined)
+                    throw new Error("insertBulk bufferKey does not exist");
+                const { bufferManager, adaptor } = bufferManagerComp;
+                bufferManager.insertBulk(items.map(adaptor), offsets);
+            }
+        }
+        else {
+            for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+                bufferManager.insertBulk(items.map(adaptor), offsets);
+            }
         }
     }
     // does not assign offset to the new items.

package/util/check/typecheck.js

@@ -2,7 +2,7 @@
 const doesOwnProperties = (properties, errorMessage) => {
     return (object) => {
         properties.forEach(element => {
-            if (!Object.hasOwn(object, element))
+            if (!object.hasOwnProperty(element))
                 throw new TypeError(errorMessage + ':' + element);
         });
     };
@@ -38,3 +38,17 @@ export const isBoolean = (x) => {
     if (typeof x !== "boolean")
         throw new TypeError("type must be boolean");
 };
+export const mapGetOrThrow = (errorNote) => {
+    return (mapInstance, ids) => {
+        if (!ids)
+            throw new Error("There is no map keys to get");
+        const result = [];
+        for (let i = 0; i < ids.length; i++) {
+            const e = mapInstance.get(ids[i]);
+            if (e === undefined)
+                throw new Error(errorNote + " " + ids[i]);
+            result.push(e);
+        }
+        return result;
+    };
+};

package/util/geometry/index.js

@@ -24,8 +24,9 @@ function latLongBboxtoPixelXYBbox(minX, minY, maxX, maxY) {
 }
 /**
  *
- * @param {Float32List} array
- * @returns {Float32Array}
+ * @param array - The array to normalize
+ * @param newLength - The target length for the normalized array
+ * @returns Normalized Float32Array
  */
 function normalize(array, newLength = 1) {
     let total = 0;

package/util/gl-util/buffer/attribute-loader.js

@@ -1,4 +1,3 @@
-import './types';
 /**
  * @typedef BufferAndReadInfo Buffers can be intertwined or interleaved.
  * This object forces user to adapt generic convention of buffer and read information.
@@ -20,10 +19,8 @@ import './types';
  * @returns
  */
 const attributeLoader = (gl, bufferAndReadInfo, index, size, { divisor = null, type = null, escapeValues = null, normalized = false } = {}) => {
-    if (size < 1 || size > 4)
-        throw new Error("Size must be between 1 and 4");
-    if (bufferAndReadInfo == null) {
-        if (escapeValues !== null)
+    if (bufferAndReadInfo == null || bufferAndReadInfo.buffer == null) {
+        if (escapeValues)
             constantFunction(gl, index, size, escapeValues);
         return;
     }

package/util/gl-util/draw-options/methods.js

@@ -1,17 +1,16 @@
-import './types';
 /**
  * Draws instanced geometry using WebGL2.
  */
 const drawInstanced = (gl, mode, drawOptions, vertexCount) => {
     const { drawRange, elementBufferIndexType = gl.UNSIGNED_INT } = drawOptions;
-    const { first = 0, count: instanceCount = 1 } = drawRange;
-    if (first > 0 || drawOptions.elementBuffer) {
+    const { first = 0, count } = drawRange;
+    if (drawOptions.elementBuffer) {
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, drawOptions.elementBuffer ?? null);
-        gl.drawElementsInstanced(mode, vertexCount, elementBufferIndexType, first, instanceCount);
+        gl.drawElementsInstanced(mode, vertexCount, elementBufferIndexType, first, count);
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
     }
     else {
-        gl.drawArraysInstanced(mode, first, vertexCount, instanceCount);
+        gl.drawArraysInstanced(mode, first, vertexCount, count);
     }
 };
 /**

package/util/webglobjectbuilders.js

@@ -34,8 +34,7 @@ export function createShader(gl, type, source) {
 export function createProgram(gl, vertexSource, fragmentSource) {
     const program = gl.createProgram();
     if (!program) {
-        console.error("Failed to create WebGLProgram.");
-        return undefined;
+        throw new Error("Failed to create WebGLProgram.");
     }
     let vertexShader;
     let fragmentShader;
@@ -45,18 +44,14 @@ export function createProgram(gl, vertexSource, fragmentSource) {
     }
     catch (e) { // Catching errors from createShader
         console.error(e.message);
-        gl.deleteProgram(program); // Clean up the program if shaders failed
-        return undefined;
+        throw new Error(`Shader creation failed: ${e.message}`);
     }
     gl.attachShader(program, vertexShader);
     gl.attachShader(program, fragmentShader);
     gl.linkProgram(program);
     if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-        console.error("Failed to link WebGL program:", gl.getProgramInfoLog(program));
-        gl.deleteProgram(program);
-        gl.deleteShader(vertexShader);
-        gl.deleteShader(fragmentShader);
-        return undefined;
+        // console.error("Failed to link WebGL program:", gl.getProgramInfoLog(program));
+        throw new Error(`Error linking program:\n${gl.getProgramInfoLog(program)}`);
     }
     // Detach and delete shaders after linking to free up resources
     gl.detachShader(program, vertexShader);

package/write-text/context-text3.js

@@ -1,3 +1,4 @@
+// @ts-ignore
 import { CSZMode } from "@pirireis/webglobe";
 import { isTextFont, opacityCheck } from "../util/check/typecheck";
 /**
@@ -9,6 +10,22 @@ import { isTextFont, opacityCheck } from "../util/check/typecheck";
  * TODO: key check and raise error if doesnt exist
  */
 export class ContextTextWriter3 {
+    globe;
+    itemMap;
+    // @ts-ignore
+    style;
+    doDraw;
+    textAdaptor;
+    coordinatesAdaptor;
+    keyAdaptor;
+    zoomLevelAdaptor;
+    positionAdaptor;
+    opacityAdaptor;
+    angleOnSphere;
+    angleAdaptor;
+    angleAdaptorIsOn;
+    xOffset;
+    yOffset;
     constructor(globe, { style = {
         textFont: {
             name: 'Arial',

package/write-text/context-text3old.js

@@ -0,0 +1,152 @@
+"use strict";
+// import { CSZMode } from "@pirireis/webglobe";
+// import { isTextFont, opacityCheck } from "../util/check/typecheck";
+// /**
+//  * TODOs:
+//  * 1) update all if initials change (propably need a context and a callback to iterate over zPayload)
+//  * 2) expose a mechanic to update text on zoom change
+//  * 3) extend the mechanic on 2 to other events
+//  *
+//  * TODO: key check and raise error if doesnt exist
+//  */
+// export class ContextTextWriter3 {
+//     constructor(globe, {
+//         style = {
+//             textFont: {
+//                 name: 'Arial',
+//                 textColor: '#FFFFFF', // beyaz
+//                 hollowColor: '#000000', // siyah
+//                 size: 12, // piksel
+//                 hollow: true,
+//                 bold: true,
+//                 italic: false,
+//             },
+//             opacity: 1.0,
+//             zMode: CSZMode.Z_GROUND_PERVERTEX,
+//         },
+//         xOffset = 0,
+//         yOffset = 0,
+//         doDraw = true,
+//         textAdaptor = null,
+//         coordinatesAdaptor = null,
+//         keyAdaptor = null,
+//         opacityAdaptor = null,
+//         angleAdaptor = null,
+//         angleOnSphere = false,
+//         positionAdaptor = (item, i, container, properties) => "left",
+//         zoomLevelAdaptor = (zoomLevel) => (item) => {
+//             return {
+//                 opacityMultiplier: 1,
+//                 sizeMultiplier: 1
+//             }
+//         }
+//     } = {}) {
+//         this.globe = globe;
+//         this.itemMap = new Map();
+//         this.setStyle(style);
+//         this.doDraw = doDraw;
+//         this._checkParameterTypes(textAdaptor, coordinatesAdaptor, keyAdaptor, opacityAdaptor, angleAdaptor, xOffset, yOffset);
+//         this.textAdaptor = textAdaptor;
+//         this.coordinatesAdaptor = coordinatesAdaptor;
+//         this.keyAdaptor = keyAdaptor;
+//         this.zoomLevelAdaptor = zoomLevelAdaptor;
+//         this.positionAdaptor = positionAdaptor;
+//         this.opacityAdaptor = opacityAdaptor ? opacityAdaptor : () => 1;
+//         this.angleOnSphere = angleOnSphere;
+//         if (angleAdaptor) {
+//             this.angleAdaptor = angleAdaptor
+//             this.angleAdaptorIsOn = true;
+//         } else {
+//             this.angleAdaptor = () => null
+//             this.angleAdaptorIsOn = false
+//         }
+//         this.xOffset = xOffset;
+//         this.yOffset = yOffset;
+//     }
+//     _checkParameterTypes(textAdaptor, coordinatesAdaptor, keyAdaptor, opacityAdaptor, angleAdaptor, xOffset, yOffset) {
+//         if (textAdaptor !== null) if (!(textAdaptor instanceof Function)) throw new Error("textAdaptor is not an instance of a Function");
+//         if (coordinatesAdaptor !== null) if (!(coordinatesAdaptor instanceof Function)) throw new Error("coordinatesAdaptor is not an instance of a Function");
+//         if (keyAdaptor !== null) if (!(keyAdaptor instanceof Function)) throw new Error("keyAdaptor is not an instance of a Function");
+//         if (opacityAdaptor !== null) if (!(opacityAdaptor instanceof Function)) throw new Error("opacityAdaptor is not an instance of a Function");
+//         if (angleAdaptor !== null) if (!(angleAdaptor instanceof Function)) throw new Error("angleAdaptor is not an instance of a Function");
+//         if (typeof xOffset !== "number") throw new Error("xOffset type is not a number");
+//         if (typeof yOffset !== "number") throw new Error("yOffset type is not a number");
+//     }
+//     setKeyAdaptor(adaptor) {
+//         this.keyAdaptor = adaptor;
+//     }
+//     setDoDraw(bool) {
+//         this.doDraw = bool;
+//         this.globe.DrawRender();
+//     }
+//     setStyle(style) {
+//         isTextFont(style.textFont);
+//         opacityCheck(style.opacity); //TODO: use shallow copy
+//         this.style = style;
+//         this.globe.DrawRender();
+//     }
+//     setOpacity(opacity) {
+//         this.style.opacity = opacity;
+//         this.globe.DrawRender();
+//     }
+//     draw() {
+//         if (!this.doDraw) return;
+//         const { globe, style, itemMap, xOffset, yOffset } = this;
+//         const { textFont, opacity: opacity_ } = style;
+//         const textSize = textFont.size;
+//         const is3D = globe.api_GetCurrentGeometry() === 0;
+//         const angleIsOn = is3D ? (this.angleAdaptorIsOn && this.angleOnSphere) : (this.angleAdaptorIsOn)
+//         const zoomLevel = globe.api_GetCurrentLODWithDecimal();
+//         const zoomAdaptor = this.zoomLevelAdaptor(zoomLevel);
+//         for (const item of itemMap.values()) {
+//             const { lat, long, text, opacity = null, angle = null, zPayload, position } = item;
+//             const { x, y } = globe.api_GetScreenPointFromGeo(
+//                 {
+//                     long: long,
+//                     lat: lat,
+//                     z: 0,
+//                 },
+//                 style.zMode === CSZMode.Z_MSL,
+//             );
+//             const { opacityMultiplier, sizeMultiplier } = zoomAdaptor(zPayload);
+//             const o = (opacity === null ? opacity_ : opacity * opacity_) * opacityMultiplier;
+//             textFont.size = sizeMultiplier * textSize;
+//             textFont.position = position;
+//             if (x !== null && y !== null) globe.api_DrawContextTextMultiLine(text, textFont, o, { x: x + xOffset, y: y - yOffset }, angleIsOn, angle);
+//         }
+//         textFont.size = textSize;
+//     }
+//     insertTextBulk(container, properties) {
+//         container.forEach((v, i, c) => {
+//             this.insertText(v, i, c, properties);
+//         });
+//     }
+//     deleteTextBulk(keys) {
+//         for (const key of keys) {
+//             this.itemMap.delete(key);
+//         }
+//     }
+//     insertText(item, id, container, properties) {
+//         const key = this.keyAdaptor(item, id, container, properties)
+//         const coords = this.coordinatesAdaptor(item, id, container, properties)
+//         if (coords == null) {
+//             this.itemMap.delete(key);
+//             return;
+//         }
+//         const text = this.textAdaptor(item, id, container, properties)
+//         if (text == null) {
+//             this.itemMap.delete(key);
+//             return
+//         };
+//         const opacity = this.opacityAdaptor(item, id, container, properties);
+//         const angle = this.angleAdaptor(item, id, container, properties);
+//         const position = this.positionAdaptor(item, id, container, properties);
+//         this.itemMap.set(key, { long: coords.long, lat: coords.lat, text, opacity, angle, zPayload: item, position });
+//     }
+//     clear() {
+//         this.itemMap.clear();
+//     }
+//     free() {
+//         this.itemMap = null;
+//     }
+// }

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

@@ -1,176 +0,0 @@
-"use strict";
-// TODO: Delete this file if it is not needed anymore.
-// import { createProgram } from "../../util/webglobjectbuilders";
-// import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../totems/camerauniformblock";
-// import { noRegisterGlobeProgramCache } from "../programcache";
-// import { vaoAttributeLoader } from "../../util/account/util";
-// import {
-//     longLatRadToMercator, longLatRadToCartesian3D, cartesian3DToGLPosition, mercatorXYToGLPosition, realDistanceOnSphereR1,
-//     circleLimpFromLongLatRadCenterCartesian3D_accurate,
-//     circleLimpFromLongLatRadCenterMercatorCompass_accurate,
-//     circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
-//     POLE
-// } from "../../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;
-// ${CameraUniformBlockString}
-// ${longLatRadToMercator}
-// ${longLatRadToCartesian3D}
-// ${cartesian3DToGLPosition}
-// ${mercatorXYToGLPosition}
-// ${realDistanceOnSphereR1}
-// ${circleLimpFromLongLatRadCenterCartesian3D_accurate}
-// ${circleLimpFromLongLatRadCenterMercatorCompass_accurate}
-// ${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
-// ${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 = 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 = 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;
-//             vaoAttributeLoader(gl, buffer, 0, 2, stride, offset, divisor);
-//         }
-//         {  // make this a function end import from account module. 
-//             const { buffer, stride = 0, offset = 0 } = center3dObj;
-//             vaoAttributeLoader(gl, buffer, 1, 3, stride, offset, divisor);
-//         }
-//         {
-//             const { buffer, stride = 0, offset = 0 } = radiusObj;
-//             vaoAttributeLoader(gl, buffer, 2, 1, stride, offset, divisor);
-//         }
-//         {
-//             const { buffer, stride = 0, offset = 0 } = colorObj;
-//             vaoAttributeLoader(gl, buffer, 3, 4, stride, offset, divisor);
-//         }
-//         {
-//             const { buffer, stride = 0, offset = 0 } = dashRatioObj;
-//             vaoAttributeLoader(gl, buffer, 4, 1, stride, offset, divisor);
-//         }
-//         {
-//             const { buffer, stride = 0, offset = 0 } = dashOpacityObj;
-//             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;
-//         CameraUniformBlockTotemCache.release(this.globe);
-//         this.gl.deleteProgram(this.program);
-//         this.isFreed = true;
-//     }
-// }
-// export const CircleCache = Object.freeze({
-//     get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
-//     release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
-// });