@pirireis/webglobeplugins 0.11.1-alpha → 0.13.0-alpha

package/programs/vectorfields/logics/pixelbased.js

@@ -34,7 +34,7 @@ vec2 read_value(const vec2 uv) {
     return value;
 }
 
-vec2 lookup_wind(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu ayni isi yapiyor
+vec2 lookup_wind(const vec2 uv) { 
     // return texture(vector_field, uv).rg; // lower-res hardware filtering
     vec2 res = vec2(textureSize(vector_field, 0));
     vec2 px = 1.0 / res;
@@ -49,23 +49,7 @@ vec2 lookup_wind(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu
 }
 
 
-vec2 lookup_wind2(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu ayni isi yapiyor
-    // return texture(vector_field, uv).rg; // lower-res hardware filtering
-    vec2 res = vec2(textureSize(vector_field, 0));
-    if (res.x == escape_value || res.y == escape_value){ return vec2(0.0);}
-    vec2 px = 1.0 / res;
-    vec2 vc = (floor(uv * res)) * px;
-    vec2 f = fract(uv * res);
-    vec2 tl = texture(vector_field, vc).rg;
-    vec2 tr = texture(vector_field, vc + vec2(px.x, 0)).rg;
-    vec2 bl = texture(vector_field, vc + vec2(0, px.y)).rg;
-    vec2 br = texture(vector_field, vc + px).rg;
-    if (tl.x == 0.0 && tl.y == 0.0){ return vec2(0.0);}
-    if (tr.x == 0.0 && tr.y == 0.0){ return vec2(0.0);}
-    if (bl.x == 0.0 && bl.y == 0.0){ return vec2(0.0);}
-    if (br.x == 0.0 && br.y == 0.0){ return vec2(0.0);}
-    return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);
-}
+
 
 
 vec2 random_position(vec2 st){
@@ -80,11 +64,11 @@ void main(){
         return;
     }
     float random_value = random(in_position + random_seed);
-    if (random_value < drop_rate){ //TODO: more sophisticated drop out mechanism mi
+    if (random_value < drop_rate){ 
         out_position = random_position(in_position);
         return;
     }
-    out_position = in_position - (vec / draw_texture_size)  * range; //*0.0014
+    out_position = in_position + (vec / draw_texture_size)  * range;
 }
 `;
 const fragmentShaderSource = `#version 300 es

package/shape-on-terrain/arc/naive/plugin.js

@@ -1,289 +1,250 @@
-"use strict";
-// import { LineStripProgramCache } from "../../../programs/line-on-globe/linestrip"
-// import "../../../programs/interface";
-// import { createBufferAndReadInfo } from '../../../util/gl-util/buffer/attribute-loader';
+import { LineStripProgramCache } from "../../../programs/line-on-globe/linestrip/linestrip";
+import { createBufferAndReadInfo } from '../../../util/gl-util/buffer/attribute-loader';
 // import { populateFloat32Array } from "../../../util/jshelpers/data-filler";
-// import { BufferManagementMap, BufferManager, BufferOrchestrator } from "../../../util/account/single-attribute-buffer-management/index";
-// import { globe3Dcoordinates, globe2Dcoordinates, RADIANS } from "../../../Math/methods";
-// import { generateArcPoints } from "../../../Math/arc-generate-points";
-// import { Vec3, Plane, Arc } from "../../../Math/types";
-// import * as vec3 from "../../../Math/vec3";
-// import * as plane from "../../../Math/plane";
-// import * as arc from "../../../Math/arc";
-// // import { arcFrustumPlanesIntersection } from "../../../Math/intersections/arc-frustum-planes";
-// import CameraUniformBlockTotem, { CameraUniformBlockTotemCache } from "../../../programs/totems/camerauniformblock";
-// import { FrustumPlanes } from "../../../Math/frustum/types";
-// const VERTEX_COUNT = 360;
-// const INITAL_CAPACITY = 10;
-// const _0vector = [0, 0, 0] as Vec3;
-// const _attractionPoint = [0, 0, 0] as Vec3;
-// const _start = [0, 0, 0] as Vec3;
-// const _end = [0, 0, 0] as Vec3;
-// const _0arc = arc.create([1, 0, 0] as Vec3, [0, 1, 0] as Vec3); // zero arc for intersection tests
-// // window add properties
-// declare global {
-//     interface Window {
-//         startPoint: Vec3;
-//         endPoint: Vec3;
-//     }
-// }
-// let interval = 1;
-// export class NaiveLineOnTerrainPlugin {
-//     public id: string;
-//     private program: ProgramInterface | null = null;
-//     private _bufferManagersCompMap: BufferManagementMap | null = null;
-//     private _bufferManagersCompMapTest: BufferManagementMap | null = null;
-//     private _bufferOrchestrator: BufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
-//     private _testOrchestrator: BufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
-//     private _opacity: number = 1;
-//     private _arcUBOHandler: UBOHandler | null = null;
-//     private _vao: WebGLVertexArrayObject | null = null;
-//     private _vaoAllTest: WebGLVertexArrayObject | null = null;
-//     private _ubohandlerAllTest: UBOHandler | null = null;
-//     private globe: any | null = null;
-//     private gl: WebGL2RenderingContext | null = null;
-//     private _arcMap: Map<string, Arc>;
-//     private _arcMapTest: Map<string, Arc>;
-//     private _screenPlane: Plane = { normal: [0, 0, 1] as Vec3, distance: 0 } as Plane;
-//     private _doBuild: boolean = false
-//     private _cameraUniformBlock: CameraUniformBlockTotem | null = null;
-//     private _attractionStrength: number = 50;
-//     public fieldOfView = 50 * RADIANS; // 50 degrees in radians
-//     constructor(id: string) {
-//         this.id = id;
-//         this._arcMap = new Map();
-//         this._arcMapTest = new Map();
-//     }
-//     insertArcFromLongLat(key: string, startPoint: { long: number, lat: number }, endPoint: { long: number, lat: number }) {
-//         if (this._arcMap.has(key)) {
-//             this._arcMap.delete(key);
-//         }
-//         vec3.fromUnitVectorLongLat(_start, [startPoint.long * RADIANS, startPoint.lat * RADIANS]);
-//         vec3.fromUnitVectorLongLat(_end, [endPoint.long * RADIANS, endPoint.lat * RADIANS]);
-//         window.startPoint = _start;
-//         window.endPoint = _end;
-//         const _arc = arc.create(_start, _end);
-//         this._arcMap.set(key, _arc);
-//         this._arcMapTest.set(key, arc.clone(_arc));
-//         // const longLatArr = new Float32Array(2 * VERTEX_COUNT);
-//         // //
-//         // const _3Dpoints = generateArcPoints(_start, _end, VERTEX_COUNT);
-//         // const longLat = {
-//         //     long: 1,
-//         //     lat: 1
-//         // };
-//         // for (let i = 0; i < _3Dpoints.length / 3; i++) {
-//         //     _0vector.set(_3Dpoints[i * 3], _3Dpoints[i * 3 + 1], _3Dpoints[i * 3 + 2]).toLongLat(longLat);
-//         //     longLatArr.set([longLat.long / RADIANS, longLat.lat / RADIANS], i * 2);
-//         // }
-//         // const result = [{
-//         //     key: key,
-//         //     longLatArr: longLatArr,
-//         // }
-//         // ]
-//         // this._testOrchestrator.insertBulk(result, this._bufferManagersCompMapTest);
-//         this._doBuild = true;
-//         this.globe.DrawRender();
-//     }
-//     init(globe: any, gl: WebGL2RenderingContext) {
-//         this.globe = globe;
-//         this.gl = gl;
-//         this.program = LineStripProgramCache.get(globe);
-//         const g3D = globe3Dcoordinates(globe, 30);
-//         const g2D = globe2Dcoordinates(globe);
-//         this._cameraUniformBlock = CameraUniformBlockTotemCache.get(globe);
-//         this._bufferManagersCompMap = new Map(
-//             [
-//                 ["position3d", {
-//                     bufferManager: new BufferManager(gl, 3 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-//                     adaptor: (item: any) => {
-//                         const { longLatArr } = item;
-//                         const result = g3D(longLatArr, { paddingCount: 1 });
-//                         // console.log("result", result);
-//                         return result;
-//                     }
-//                 }],
-//                 ["position2d", {
-//                     bufferManager: new BufferManager(gl, 2 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-//                     adaptor: (item: any) => {
-//                         const { longLatArr } = item;
-//                         return g2D(longLatArr, { paddingCount: 1 });
-//                     }
-//                 }
-//                 ],
-//             ]
-//         );
-//         this._bufferManagersCompMapTest = new Map([
-//             ["positionTest3d", {
-//                 bufferManager: new BufferManager(gl, 3 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-//                 adaptor: (item: any) => {
-//                     const { longLatArr } = item;
-//                     const result = g3D(longLatArr, { paddingCount: 1 });
-//                     return result;
-//                 }
-//             }],
-//             ["positionTest2d", {
-//                 bufferManager: new BufferManager(gl, 2 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-//                 adaptor: (item: any) => {
-//                     const { longLatArr } = item;
-//                     return g2D(longLatArr, { paddingCount: 1 });
-//                 }
-//             }
-//             ]
-//         ]
-//         );
-//         this._bufferOrchestrator = new BufferOrchestrator();
-//         this._arcUBOHandler = this.program.createUBO();
-//         this._arcUBOHandler.update(new Map([
-//             ["u_color", new Float32Array([1, 0, 0, 1])],
-//         ]));
-//         this._ubohandlerAllTest = this.program.createUBO();
-//         this._ubohandlerAllTest.update(new Map([
-//             ["u_color", new Float32Array([0, 0, 1, 1])],
-//         ]));
-//         this._vao = this.program.createVAO(
-//             createBufferAndReadInfo(this._bufferManagersCompMap.get("position3d")?.bufferManager.buffer as WebGLBuffer),
-//             createBufferAndReadInfo(this._bufferManagersCompMap.get("position2d")?.bufferManager.buffer as WebGLBuffer),
-//             null,
-//             null,
-//             null,
-//         );
-//         this._vaoAllTest = this.program.createVAO(
-//             createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest3d")?.bufferManager.buffer as WebGLBuffer),
-//             createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest2d")?.bufferManager.buffer as WebGLBuffer),
-//             null,
-//             null,
-//             null,
-//         );
-//     }
-//     setFieldOfView(fieldOfView: number) {
-//         this.fieldOfView = fieldOfView * RADIANS; // convert degrees to radians
-//         this.globe.DrawRender();
-//     }
-//     _buildArcs() {
-//         const { globe, _arcMap, _cameraUniformBlock } = this;
-//         const cameraPositionNormalized = _cameraUniformBlock.getCameraPositionNormalized() as Vec3;
-//         const result = [];
-//         const longLat = [0, 0] as [number, number];
-//         for (const [key, arcInstance] of _arcMap) {
-//             arc.copy(_0arc, arcInstance);
-//             const isOnArc = arc.closestPoint(_attractionPoint, _0arc, cameraPositionNormalized);
-//             if (!isOnArc) {
-//                 vec3.distanceSquared(cameraPositionNormalized, _0arc.p0) < vec3.distanceSquared(cameraPositionNormalized, _0arc.p1) ?
-//                     vec3.copy(_attractionPoint, _0arc.p0) : vec3.copy(_attractionPoint, _0arc.p1);
-//             }
-//             const generatedPoints = generateArcPoints(_0arc.p0, _0arc.p1, _0arc.normal, _attractionPoint, VERTEX_COUNT, this._attractionStrength);
-//             const longLatArr = new Float32Array(2 * VERTEX_COUNT);
-//             for (let i = 0; i < generatedPoints.length; i++) {
-//                 const point = generatedPoints[i];
-//                 vec3.toUnitVectorLongLat(longLat, point);
-//                 longLatArr.set([longLat[0] / RADIANS, longLat[1] / RADIANS], i * 2);
-//             }
-//             result.push({
-//                 key: key,
-//                 longLatArr: longLatArr,
-//             })
-//         }
-//         this._bufferOrchestrator.resetWithCapacity(this._bufferManagersCompMap, result.length);
-//         this._bufferOrchestrator.insertBulk(result, this._bufferManagersCompMap);
-//         this._doBuild = false; // reset build flag
-//         this._checkIfCorrupted(); // check if any arc is corrupted
-//     }
-//     setAttractionStrength(strength: number) {
-//         this._attractionStrength = strength;
-//         this._doBuild = true; // trigger rebuild
-//         this.globe.DrawRender();
-//     }
-//     // _buildArcs() {
-//     //     // updatePlane
-//     //     const { globe, _arcMap } = this;
-//     //     const planes = this._cameraUniformBlock.getFrustumPlanes() as FrustumPlanes;
-//     //     //
-//     //     const cameraPostition = new Vector3D();
-//     //     cameraPostition.copy(globe.Fp as Vector3D).normalize();
-//     //     // calculateHorizonPlane(globe, _screenPlane, this.fieldOfView);
-//     //     const result = [];
-//     //     const longLat = {
-//     //         long: 1,
-//     //         lat: 1
-//     //     }
-//     //     let counter = 0;
-//     //     for (const [key, arc] of _arcMap) {
-//     //         // const isArc = arc.intersectionMedium(_screenPlane, _0arc) as Arc;
-//     //         _0arc.copy(arc);
-//     //         const isArc = arcFrustumPlanesIntersection(_0arc, planes, _0arc);
-//     //         if (!isArc) {
-//     //             continue;
-//     //         }
-//     //         counter++;
-//     //         const longLatArr = new Float32Array(2 * VERTEX_COUNT);
-//     //         // const _3Dpoints = _0arc.populatePoints3DInRespectToCamera(cameraPostition, VERTEX_COUNT);
-//     //         const _3Dpoints = _0arc.populatePoints3D(VERTEX_COUNT);
-//     //         for (let i = 0; i < _3Dpoints.length / 3; i++) {
-//     //             _0vector.set(_3Dpoints[i * 3], _3Dpoints[i * 3 + 1], _3Dpoints[i * 3 + 2]).toLongLat(longLat);
-//     //             longLatArr.set([longLat.long / RADIANS, longLat.lat / RADIANS], i * 2);
-//     //         }
-//     //         result.push({
-//     //             key: key,
-//     //             longLatArr: longLatArr,
-//     //         });
-//     //         // if (!arc.imaginaryPlane.equals(_0arc.imaginaryPlane) || !arc.imaginaryPlane.equalsReverseOriantation(_0arc.imaginaryPlane)) {
-//     //         //     // console.log("Arc with key", key, "has imaginary plane equal to the original arc's imaginary plane.");
-//     //         //     throw new Error("The arc segment is not on the parent arc")
-//     //         // }
-//     //     }
-//     //     interval += 1;
-//     //     if (interval === 100) {
-//     //         interval = 1;
-//     //         console.log("Arc count on screen:", counter);
-//     //     }
-//     //     // update buffer
-//     //     this._bufferOrchestrator.resetWithCapacity(this._bufferManagersCompMap, result.length);
-//     //     this._bufferOrchestrator.insertBulk(result, this._bufferManagersCompMap);
-//     //     this._doBuild = false;
-//     //     this._checkIfCorrupted(); // check if any arc is corrupted
-//     // }
-//     draw3D() {
-//         // Drawing logic here
-//         this._buildArcs() // can be async
-//         const { gl, program, _bufferOrchestrator } = this;
-//         gl.disable(gl.DEPTH_TEST);
-//         const drawOptionTest = {
-//             drawRange: {
-//                 first: 0,
-//                 count: this._testOrchestrator.length * (VERTEX_COUNT + 1)
-//             },
-//             indexes: null
-//         }
-//         program.draw(
-//             this._vaoAllTest,
-//             drawOptionTest,
-//             this._opacity,
-//             this._ubohandlerAllTest
-//         );
-//         const drawOptions = {
-//             drawRange: {
-//                 first: 0,
-//                 count: _bufferOrchestrator.length * (VERTEX_COUNT + 1)
-//             },
-//             indexes: null
-//         }
-//         program.draw(
-//             this._vao,
-//             drawOptions,
-//             this._opacity,
-//             this._arcUBOHandler
-//         );
-//         gl.enable(gl.DEPTH_TEST);
-//     }
-//     _checkIfCorrupted() {
-//         for (const [key, arc] of this._arcMap) {
-//             if (!arc.p0.equals(arc.p1)) {
-//                 continue; // valid arc
-//             }
-//             console.warn(`Arc with key ${key} is corrupted: p0 and p1 are the same point.`);
-//             // this._arcMap.delete(key);
-//             // this._arcMapTest.delete(key);
-//         }
-//     }
-// }
+import { BufferManager, BufferOrchestrator } from "../../../util/account/single-attribute-buffer-management/index";
+import { globe3Dcoordinates, globe2Dcoordinates, RADIANS } from "../../../Math/methods";
+import { generateArcPoints } from "../../../Math/arc-cdf-points";
+import { StaticDynamicState, StaticDynamicStrategy } from "../../../util/build-strategy/static-dynamic";
+import * as vec3 from "../../../Math/vec3";
+import * as arc from "../../../Math/arc";
+import { CameraUniformBlockTotemCache } from "../../../programs/totems/camerauniformblock";
+import { WORLD_RADIUS_3D } from "../../../Math/constants";
+const VERTEX_COUNT = 70;
+const INITAL_CAPACITY = 10;
+const _attractionPoint = [0, 0, 0];
+const _start = [0, 0, 0];
+const _end = [0, 0, 0];
+const _0arc = arc.create([1, 0, 0], [0, 1, 0]); // zero arc for intersection tests
+const _colorArray = new Float32Array(4); // For color buffer
+export class NaiveLineOnTerrainPlugin {
+    id;
+    program = null;
+    bufferManagerMap = null;
+    _bufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
+    _opacity = 1;
+    _arcUBOHandler = null;
+    _vao = null;
+    globe = null;
+    gl = null;
+    _arcMap;
+    _cameraUniformBlock = null;
+    _staticDynamicStrategy = null;
+    _styleOptions = {
+        variativeColorsOn: false,
+        defaultColor: [0.1, 0.1, 1, 1], // Default color in RGBA format
+        defaultHeightFromGroundIn3D: 30.0 // Default height from ground in
+    };
+    constructor(id, drawStyleOptions = null) {
+        this.id = id;
+        this._arcMap = new Map();
+        if (drawStyleOptions) {
+            this._styleOptions = drawStyleOptions;
+        }
+    }
+    insertArcFromLongLat(key, startPoint, endPoint, height = null) {
+        if (this._arcMap.has(key)) {
+            this._arcMap.delete(key);
+        }
+        vec3.fromLongLatToUnitVector(_start, [startPoint.long * RADIANS, startPoint.lat * RADIANS]);
+        vec3.fromLongLatToUnitVector(_end, [endPoint.long * RADIANS, endPoint.lat * RADIANS]);
+        const _arc = arc.create(_start, _end);
+        this._arcMap.set(key, [_arc, height]);
+        // TODO: insert into buffer if NOT DYNAMIC state
+        if (this._staticDynamicStrategy?.getState() !== StaticDynamicState.DYNAMIC) {
+            this.__buildStaticArcs([key]);
+        }
+        this.globe.DrawRender();
+    }
+    deleteArcs(keys) {
+        for (const key of keys) {
+            if (this._arcMap.has(key)) {
+                this._arcMap.delete(key);
+            }
+        }
+        // DELETE FROM BUFFER IF not DYNAMIC state
+        this.globe.DrawRender();
+    }
+    init(globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        this.program = LineStripProgramCache.get(globe);
+        this._staticDynamicStrategy = new StaticDynamicStrategy(globe, 8); // Initialize static-dynamic strategy with a transition level of 8
+        const g2D = globe2Dcoordinates(globe);
+        this._cameraUniformBlock = CameraUniformBlockTotemCache.get(globe);
+        this._staticDynamicStrategy = new StaticDynamicStrategy(globe, 8); // Initialize static-dynamic strategy with a transition level of 8
+        this.bufferManagerMap = new Map([
+            ["position3d", {
+                    bufferManager: new BufferManager(gl, 3 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
+                    adaptor: (item) => {
+                        const { longLatArr, height = this._styleOptions.defaultHeightFromGroundIn3D } = item;
+                        const result = globe3Dcoordinates(globe, height)(longLatArr, { paddingCount: 1 });
+                        // console.log("result", result);
+                        return result;
+                    }
+                }],
+            ["position2d", {
+                    bufferManager: new BufferManager(gl, 2 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
+                    adaptor: (item) => {
+                        const { longLatArr } = item;
+                        return g2D(longLatArr, { paddingCount: 1 });
+                    }
+                }
+            ],
+        ]);
+        if (this._styleOptions.variativeColorsOn) {
+            this.bufferManagerMap.set("color", {
+                bufferManager: new BufferManager(gl, 4, { initialCapacity: INITAL_CAPACITY }),
+                adaptor: (item) => {
+                    const { radius } = item;
+                    // Calculate color based on radius
+                    if (item.color) {
+                        _colorArray.set(item.color);
+                        return _colorArray;
+                    }
+                    else {
+                        return this._styleOptions.defaultColor;
+                    }
+                }
+            });
+        }
+        this._bufferOrchestrator = new BufferOrchestrator();
+        this._arcUBOHandler = this.program.createUBO();
+        this._arcUBOHandler.update(new Map([
+            ["u_color", new Float32Array([1, 0, 0, 1])],
+        ]));
+        this._vao = this.program.createVAO(createBufferAndReadInfo(this.bufferManagerMap.get("position3d")?.bufferManager.buffer), createBufferAndReadInfo(this.bufferManagerMap.get("position2d")?.bufferManager.buffer), null);
+    }
+    draw3D() {
+        // Drawing logic here
+        if (!this.globe || !this.gl) {
+            console.warn("Globe or WebGL context is not initialized.");
+            return;
+        }
+        this._staticDynamicStrategy?.updateState();
+        this._buildArcs(); // can be async
+        const { gl, program, _bufferOrchestrator, _vao, _arcUBOHandler, } = this;
+        if (!gl || !program || !_bufferOrchestrator || !_vao || !_arcUBOHandler) {
+            console.warn("WebGL context, program, or buffer orchestrator is not initialized.");
+            return;
+        }
+        gl.disable(gl.DEPTH_TEST);
+        const drawOptions = {
+            drawRange: {
+                first: 0,
+                count: _bufferOrchestrator.length * (VERTEX_COUNT + 1)
+            },
+            indexes: null
+        };
+        program.draw(_vao, drawOptions, this._opacity, _arcUBOHandler);
+        gl.enable(gl.DEPTH_TEST);
+    }
+    _buildArcs() {
+        const state = this._staticDynamicStrategy?.getState();
+        if (state === StaticDynamicState.TO_STATIC) {
+            this.__buildStaticArcs();
+        }
+        else if (state === StaticDynamicState.DYNAMIC) {
+            this.__buildArcs();
+        }
+    }
+    __buildStaticArcs(keys = []) {
+        const { globe, _arcMap, _cameraUniformBlock, bufferManagerMap, _bufferOrchestrator } = this;
+        if (!globe || !_cameraUniformBlock || !bufferManagerMap || !_bufferOrchestrator) {
+            console.warn("Globe or camera uniform block is not initialized.");
+            return;
+        }
+        const longLat = [0, 0];
+        const _attractionStrength = 0;
+        const longLatArr = new Float32Array(2 * VERTEX_COUNT);
+        const data = [{
+                key: "staticArcs",
+                longLatArr: longLatArr,
+                height: null
+            }];
+        if (keys.length == 0) {
+            for (const [key, [arcInstance, height]] of _arcMap) {
+                arc.copy(_0arc, arcInstance);
+                const generatedPoints = generateArcPoints(_0arc.p0, _0arc.p1, _0arc.normal, _attractionPoint, VERTEX_COUNT, _attractionStrength);
+                for (let i = 0; i < generatedPoints.length; i++) {
+                    const point = generatedPoints[i];
+                    vec3.fromUnitVectorToLongLat(longLat, point);
+                    longLatArr.set([longLat[0] / RADIANS, longLat[1] / RADIANS], i * 2);
+                }
+                data[0].key = key;
+                data[0].height = height;
+                this._bufferOrchestrator.insertBulk(data, bufferManagerMap);
+            }
+        }
+        else {
+            for (let key of keys) {
+                if (!_arcMap.has(key)) {
+                    console.warn(`Arc with key ${key} not found in arcMap.`);
+                    continue;
+                }
+                const [arcInstance, height] = _arcMap.get(key);
+                arc.copy(_0arc, arcInstance);
+                const generatedPoints = generateArcPoints(_0arc.p0, _0arc.p1, _0arc.normal, _attractionPoint, VERTEX_COUNT, _attractionStrength);
+                for (let i = 0; i < generatedPoints.length; i++) {
+                    const point = generatedPoints[i];
+                    vec3.fromUnitVectorToLongLat(longLat, point);
+                    longLatArr.set([longLat[0] / RADIANS, longLat[1] / RADIANS], i * 2);
+                }
+                data[0].key = key;
+                data[0].height = height;
+                this._bufferOrchestrator.insertBulk(data, bufferManagerMap);
+            }
+        }
+    }
+    __buildArcs() {
+        const { globe, _arcMap, _cameraUniformBlock, bufferManagerMap } = this;
+        if (!globe || !_cameraUniformBlock || !bufferManagerMap) {
+            console.warn("Globe or camera uniform block is not initialized.");
+            return;
+        }
+        const lookAtPosition = _cameraUniformBlock.getLookAtVector();
+        const cameraPosition = _cameraUniformBlock.getCameraVector();
+        vec3.divideScalar(cameraPosition, cameraPosition, WORLD_RADIUS_3D);
+        vec3.add(cameraPosition, cameraPosition, lookAtPosition);
+        // vec3.normalize(cameraPosition, cameraPosition);
+        vec3.divideScalar(cameraPosition, cameraPosition, 2);
+        // vec3.multiplyScalar(cameraPosition, cameraPosition, 1.3);
+        const _attractionStrength = (() => {
+            const lod = globe.api_GetCurrentLODWithDecimal();
+            if (lod < 11) {
+                return 1;
+            }
+            return lod * (lod - 8.5);
+        })();
+        console.log("Attraction strength: ", _attractionStrength);
+        const result = [];
+        const longLat = [0, 0];
+        for (const [key, [arcInstance, height]] of _arcMap) {
+            arc.copy(_0arc, arcInstance);
+            const isOnArc = arc.closestPoint(_attractionPoint, _0arc, cameraPosition);
+            if (!isOnArc) {
+                if (vec3.distanceSquared(cameraPosition, _0arc.p0) < vec3.distanceSquared(cameraPosition, _0arc.p1)) {
+                    vec3.copy(_attractionPoint, _0arc.p0);
+                }
+                else {
+                    vec3.copy(_attractionPoint, _0arc.p1);
+                }
+            }
+            const generatedPoints = generateArcPoints(_0arc.p0, _0arc.p1, _0arc.normal, _attractionPoint, VERTEX_COUNT, _attractionStrength);
+            const longLatArr = new Float32Array(2 * VERTEX_COUNT);
+            for (let i = 0; i < generatedPoints.length; i++) {
+                const point = generatedPoints[i];
+                vec3.fromUnitVectorToLongLat(longLat, point);
+                longLatArr.set([longLat[0] / RADIANS, longLat[1] / RADIANS], i * 2);
+            }
+            result.push({
+                key: key,
+                longLatArr: longLatArr,
+                height: height
+            });
+        }
+        this._bufferOrchestrator.resetWithCapacity(bufferManagerMap, result.length);
+        this._bufferOrchestrator.insertBulk(result, bufferManagerMap);
+    }
+    _buildStaticArc() {
+    }
+}