@pirireis/webglobeplugins 0.12.0-alpha → 0.13.0-alpha

package/programs/rings/distancering/paddyflatprogram3d.js

@@ -1,136 +1,128 @@
-import { createProgram, shaderfunctions } from "../../../util";
-import CameraUniformBlockTotem, { CameraUniformBlockString } from "../../totems/camerauniformblock";
-import { globeProgramCache, noRegisterGlobeProgramCache } from "../../programcache";
-const vertexShader = `#version 300 es ` +
-    shaderfunctions.PI +
-    shaderfunctions.R +
-    shaderfunctions.POLE +
-    CameraUniformBlockString +
-    shaderfunctions.mercatorXYToGLPosition +
-    shaderfunctions.longLatRadToMercator +
-    shaderfunctions.longLatRadToCartesian3D +
-    shaderfunctions.circleLimpFromLongLatRadCenterCartesian3D +
-    shaderfunctions.circleLimpFromLongLatRadCenterMercatorCompass +
-    shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistancePadding +
-    shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistance + `
-
-in vec2 center;
-in float radius;
-in float pad_range;
-in vec4 color;
-in float flag;
-
-uniform int compass;
-uniform float pad_count;
-
-uniform float opacity;
-
-
-out vec2 v_limp;
-out vec4 v_color;
-
-
-void main() {   
-
-    float alpha_padding =  z_level * z_level / (pad_range/ 100.0 );
-    if( flag == 2.0 || flag == 1.0 || radius == 0.0 || alpha_padding < 0.1 || z_level < 3.0 ) return; // 1.0 is hide 
-    v_color = vec4(color.rgb, color.a * alpha_padding * opacity);
-
-    gl_PointSize = 2.0;
-
-    float odd = mod(float(gl_VertexID), 2.0);
-    float index = (float(gl_VertexID)- odd ) / 2.0;
-    float angle = 3.1415926535897932384626433832795 * 2.0 * (index / pad_count );
-    float radius_ = radius - (pad_range * odd);
-
-    if ( is3D){  
-        gl_Position = projection * view * vec4(
-            circleLimpFromLongLatRadCenterCartesian3D( center, radius_, angle) - translate, 1.0);
-        v_limp = vec2(0.0, 0.0);
-        return;
-    }
-    vec2 limp;
-    if ( compass == 1 ){
-        limp = circleLimpFromLongLatRadCenterMercatorCompass(center , radius_, angle);
-    } else {
-        // limp = circleLimpFromLongLatRadCenterMercatorRealDistancePadding(center, radius_, angle);
-        limp = circleLimpFromLongLatRadCenterMercatorRealDistance(center, radius_, angle);
-    }
-    v_limp = limp;
-    gl_Position = mercatorXYToGLPosition(limp);
-}`;
-const fragmentShader = `#version 300 es
-precision highp float; ` +
-    shaderfunctions.POLE + `
-in vec4 v_color;
-in vec2 v_limp;
-out vec4 outColor;
-void main() {
-    if ( v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE ){ discard; }
-    outColor = v_color;
-}`;
-class Logic {
-    constructor(globe) {
-        this.globe = globe;
-        this.gl = globe.gl;
-        this.program = createProgram(this.gl, vertexShader, fragmentShader);
-        { // bind positions so bufferManager can use them
-            this.gl.bindAttribLocation(this.program, 0, "center");
-            this.gl.bindAttribLocation(this.program, 1, "radius");
-            this.gl.bindAttribLocation(this.program, 2, "pad_range");
-            this.gl.bindAttribLocation(this.program, 3, "color");
-            this.gl.bindAttribLocation(this.program, 4, "flag");
-        }
-        this.cameraBlockBindingPoint = 0;
-        const cameraBlockIndex = this.gl.getUniformBlockIndex(this.program, "CameraUniformBlock");
-        this.gl.uniformBlockBinding(this.program, cameraBlockIndex, this.cameraBlockBindingPoint);
-        this.cameraBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
-        this._padCountLocation = this.gl.getUniformLocation(this.program, "pad_count");
-        this._opacityLocation = this.gl.getUniformLocation(this.program, "opacity");
-        this._compassLocation = this.gl.getUniformLocation(this.program, "compass");
-        this._compassMode = 1;
-        this._opacity = 1.0;
-        this._padCount = 360;
-        {
-            const currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
-            this.gl.useProgram(this.program);
-            this.gl.uniform1i(this._compassLocation, 1);
-            this.gl.uniform1f(this._opacityLocation, 1.0);
-            this.gl.uniform1f(this._padCountLocation, 360);
-            this.gl.useProgram(currentProgram);
-        }
-    }
-    draw(attrBufferManager, padCount, compass, opacity) {
-        const { gl, program, _padCountLocation, cameraBlockBindingPoint, cameraBlockTotem, _compassLocation } = this;
-        gl.useProgram(program);
-        attrBufferManager.bindPaddingVAO();
-        cameraBlockTotem.bind(cameraBlockBindingPoint);
-        // draw instanced
-        if (padCount !== this._padCount) {
-            this._padCount = padCount;
-            // console.log("padCount", padCount);
-            gl.uniform1f(_padCountLocation, padCount);
-        }
-        if (compass !== this._compassMode) {
-            // console.log("compass", compass);
-            gl.uniform1i(_compassLocation, compass);
-            this._compassMode = compass;
-        }
-        if (opacity !== this._opacity) {
-            // console.log("opacity", opacity);
-            this._opacity = opacity;
-            gl.uniform1f(this._opacityLocation, opacity);
-        }
-        gl.drawArraysInstanced(gl.LINES, 0, padCount * 2, attrBufferManager.length);
-        gl.bindVertexArray(null);
-        cameraBlockTotem.unbind(cameraBlockBindingPoint);
-    }
-    free() {
-        this.gl.deleteProgram(this.program);
-        globeProgramCache.releaseProgram(this.globe, CameraUniformBlockTotem);
-    }
-}
-export const PaddingProgramCache = Object.freeze({
-    getProgram: (globe) => { return noRegisterGlobeProgramCache.getProgram(globe, Logic); },
-    releaseProgram: (globe) => { noRegisterGlobeProgramCache.releaseProgram(globe, Logic); }
-});
+"use strict";
+// TODO: Delete this file if it is not needed anymore.
+// import { createProgram, shaderfunctions } from "../../../util";
+// import CameraUniformBlockTotem, { CameraUniformBlockString } from "../../totems/camerauniformblock";
+// import { globeProgramCache, noRegisterGlobeProgramCache } from "../../programcache";
+// const vertexShader = `#version 300 es ` +
+//     shaderfunctions.PI +
+//     shaderfunctions.R +
+//     shaderfunctions.POLE +
+//     CameraUniformBlockString +
+//     shaderfunctions.mercatorXYToGLPosition +
+//     shaderfunctions.longLatRadToMercator +
+//     shaderfunctions.longLatRadToCartesian3D +
+//     shaderfunctions.circleLimpFromLongLatRadCenterCartesian3D +
+//     shaderfunctions.circleLimpFromLongLatRadCenterMercatorCompass +
+//     shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistancePadding +
+//     shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistance + `
+// in vec2 center;
+// in float radius;
+// in float pad_range;
+// in vec4 color;
+// in float flag;
+// uniform int compass;
+// uniform float pad_count;
+// uniform float opacity;
+// out vec2 v_limp;
+// out vec4 v_color;
+// void main() {
+//     float alpha_padding =  z_level * z_level / (pad_range/ 100.0 );
+//     if( flag == 2.0 || flag == 1.0 || radius == 0.0 || alpha_padding < 0.1 || z_level < 3.0 ) return; // 1.0 is hide
+//     v_color = vec4(color.rgb, color.a * alpha_padding * opacity);
+//     gl_PointSize = 2.0;
+//     float odd = mod(float(gl_VertexID), 2.0);
+//     float index = (float(gl_VertexID)- odd ) / 2.0;
+//     float angle = 3.1415926535897932384626433832795 * 2.0 * (index / pad_count );
+//     float radius_ = radius - (pad_range * odd);
+//     if ( is3D){
+//         gl_Position = projection * view * vec4(
+//             circleLimpFromLongLatRadCenterCartesian3D( center, radius_, angle) - translate, 1.0);
+//         v_limp = vec2(0.0, 0.0);
+//         return;
+//     }
+//     vec2 limp;
+//     if ( compass == 1 ){
+//         limp = circleLimpFromLongLatRadCenterMercatorCompass(center , radius_, angle);
+//     } else {
+//         // limp = circleLimpFromLongLatRadCenterMercatorRealDistancePadding(center, radius_, angle);
+//         limp = circleLimpFromLongLatRadCenterMercatorRealDistance(center, radius_, angle);
+//     }
+//     v_limp = limp;
+//     gl_Position = mercatorXYToGLPosition(limp);
+// }`;
+// const fragmentShader = `#version 300 es
+// precision highp float; `+
+//     shaderfunctions.POLE + `
+// in vec4 v_color;
+// in vec2 v_limp;
+// out vec4 outColor;
+// void main() {
+//     if ( v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE ){ discard; }
+//     outColor = v_color;
+// }`;
+// class Logic {
+//     constructor(globe) {
+//         this.globe = globe;
+//         this.gl = globe.gl;
+//         this.program = createProgram(this.gl, vertexShader, fragmentShader);
+//         { // bind positions so bufferManager can use them
+//             this.gl.bindAttribLocation(this.program, 0, "center");
+//             this.gl.bindAttribLocation(this.program, 1, "radius");
+//             this.gl.bindAttribLocation(this.program, 2, "pad_range");
+//             this.gl.bindAttribLocation(this.program, 3, "color");
+//             this.gl.bindAttribLocation(this.program, 4, "flag");
+//         }
+//         this.cameraBlockBindingPoint = 0;
+//         const cameraBlockIndex = this.gl.getUniformBlockIndex(this.program, "CameraUniformBlock");
+//         this.gl.uniformBlockBinding(this.program, cameraBlockIndex, this.cameraBlockBindingPoint);
+//         this.cameraBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
+//         this._padCountLocation = this.gl.getUniformLocation(this.program, "pad_count");
+//         this._opacityLocation = this.gl.getUniformLocation(this.program, "opacity");
+//         this._compassLocation = this.gl.getUniformLocation(this.program, "compass");
+//         this._compassMode = 1;
+//         this._opacity = 1.0;
+//         this._padCount = 360;
+//         {
+//             const currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
+//             this.gl.useProgram(this.program);
+//             this.gl.uniform1i(this._compassLocation, 1);
+//             this.gl.uniform1f(this._opacityLocation, 1.0);
+//             this.gl.uniform1f(this._padCountLocation, 360)
+//             this.gl.useProgram(currentProgram);
+//         }
+//     }
+//     draw(attrBufferManager, padCount, compass, opacity) {
+//         const { gl, program, _padCountLocation, cameraBlockBindingPoint, cameraBlockTotem, _compassLocation } = this;
+//         gl.useProgram(program);
+//         attrBufferManager.bindPaddingVAO();
+//         cameraBlockTotem.bind(cameraBlockBindingPoint);
+//         // draw instanced
+//         if (padCount !== this._padCount) {
+//             this._padCount = padCount;
+//             // console.log("padCount", padCount);
+//             gl.uniform1f(_padCountLocation, padCount);
+//         }
+//         if (compass !== this._compassMode) {
+//             // console.log("compass", compass);
+//             gl.uniform1i(_compassLocation, compass);
+//             this._compassMode = compass;
+//         }
+//         if (opacity !== this._opacity) {
+//             // console.log("opacity", opacity);
+//             this._opacity = opacity;
+//             gl.uniform1f(this._opacityLocation, opacity);
+//         }
+//         gl.drawArraysInstanced(gl.LINES, 0, padCount * 2, attrBufferManager.length);
+//         gl.bindVertexArray(null);
+//         cameraBlockTotem.unbind(cameraBlockBindingPoint);
+//     }
+//     free() {
+//         this.gl.deleteProgram(this.program);
+//         globeProgramCache.releaseProgram(this.globe, CameraUniformBlockTotem);
+//     }
+// }
+// //
+// export const PaddingProgramCache = Object.freeze({
+//     getProgram: (globe) => { return noRegisterGlobeProgramCache.getProgram(globe, Logic) },
+//     releaseProgram: (globe) => { noRegisterGlobeProgramCache.releaseProgram(globe, Logic) }
+// })

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){
@@ -74,17 +58,17 @@ vec2 random_position(vec2 st){
 
 
 void main(){
-    vec2 vec = -lookup_wind(in_position).xy;
+    vec2 vec = lookup_wind(in_position).xy;
     if (vec.x == 0.0 && vec.y == 0.0){
         out_position = random_position(in_position);
         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,55 +1,58 @@
-import { LineStripProgramCache } from "../../../programs/line-on-globe/linestrip";
+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 { 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 _0vector = [0, 0, 0];
 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
-let interval = 1;
+const _colorArray = new Float32Array(4); // For color buffer
 export class NaiveLineOnTerrainPlugin {
     id;
     program = null;
-    _bufferManagersCompMap = null;
-    _bufferManagersCompMapTest = null;
+    bufferManagerMap = null;
     _bufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
-    _testOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
     _opacity = 1;
     _arcUBOHandler = null;
     _vao = null;
-    _vaoAllTest = null;
-    _ubohandlerAllTest = null;
     globe = null;
     gl = null;
     _arcMap;
-    _arcMapTest;
-    _doBuild = false;
     _cameraUniformBlock = null;
-    _attractionStrength = 8;
-    constructor(id) {
+    _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();
-        this._arcMapTest = new Map();
+        if (drawStyleOptions) {
+            this._styleOptions = drawStyleOptions;
+        }
     }
-    insertArcFromLongLat(key, startPoint, endPoint) {
+    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);
-        this._arcMapTest.set(key, arc.clone(_arc));
-        this._doBuild = true;
+        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) {
@@ -58,22 +61,23 @@ export class NaiveLineOnTerrainPlugin {
                 this._arcMap.delete(key);
             }
         }
-        this._doBuild = true;
+        // DELETE FROM BUFFER IF not DYNAMIC state
         this.globe.DrawRender();
     }
     init(globe, gl) {
         this.globe = globe;
         this.gl = gl;
         this.program = LineStripProgramCache.get(globe);
-        const g3D = globe3Dcoordinates(globe, 30);
+        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._bufferManagersCompMap = new Map([
+        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 } = item;
-                        const result = g3D(longLatArr, { paddingCount: 1 });
+                        const { longLatArr, height = this._styleOptions.defaultHeightFromGroundIn3D } = item;
+                        const result = globe3Dcoordinates(globe, height)(longLatArr, { paddingCount: 1 });
                         // console.log("result", result);
                         return result;
                     }
@@ -87,42 +91,39 @@ export class NaiveLineOnTerrainPlugin {
                 }
             ],
         ]);
-        this._bufferManagersCompMapTest = new Map([
-            ["positionTest3d", {
-                    bufferManager: new BufferManager(gl, 3 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-                    adaptor: (item) => {
-                        const { longLatArr } = item;
-                        const result = g3D(longLatArr, { paddingCount: 1 });
-                        return result;
+        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;
                     }
-                }],
-            ["positionTest2d", {
-                    bufferManager: new BufferManager(gl, 2 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-                    adaptor: (item) => {
-                        const { longLatArr } = item;
-                        return g2D(longLatArr, { paddingCount: 1 });
+                    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._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), createBufferAndReadInfo(this._bufferManagersCompMap.get("position2d")?.bufferManager.buffer), null, null, null);
-        this._vaoAllTest = this.program.createVAO(createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest3d")?.bufferManager.buffer), createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest2d")?.bufferManager.buffer), null, null, null);
+        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, _vaoAllTest, _ubohandlerAllTest, _testOrchestrator } = this;
-        if (!gl || !program || !_bufferOrchestrator || !_vao || !_arcUBOHandler
-            || !_vaoAllTest || !_ubohandlerAllTest || !_testOrchestrator) {
+        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;
         }
@@ -138,10 +139,65 @@ export class NaiveLineOnTerrainPlugin {
         gl.enable(gl.DEPTH_TEST);
     }
     _buildArcs() {
-        if (!this._doBuild)
-            return; // if not needed to build, return early
-        const { globe, _arcMap, _cameraUniformBlock, _bufferManagersCompMap } = this;
-        if (!globe || !_cameraUniformBlock || !_bufferManagersCompMap) {
+        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;
         }
@@ -162,7 +218,7 @@ export class NaiveLineOnTerrainPlugin {
         console.log("Attraction strength: ", _attractionStrength);
         const result = [];
         const longLat = [0, 0];
-        for (const [key, arcInstance] of _arcMap) {
+        for (const [key, [arcInstance, height]] of _arcMap) {
             arc.copy(_0arc, arcInstance);
             const isOnArc = arc.closestPoint(_attractionPoint, _0arc, cameraPosition);
             if (!isOnArc) {
@@ -183,23 +239,12 @@ export class NaiveLineOnTerrainPlugin {
             result.push({
                 key: key,
                 longLatArr: longLatArr,
+                height: height
             });
         }
-        this._bufferOrchestrator.resetWithCapacity(_bufferManagersCompMap, result.length);
-        this._bufferOrchestrator.insertBulk(result, _bufferManagersCompMap);
-        this._doBuild = false; // reset build flag
-        this._checkIfCorrupted(); // check if any arc is corrupted
+        this._bufferOrchestrator.resetWithCapacity(bufferManagerMap, result.length);
+        this._bufferOrchestrator.insertBulk(result, bufferManagerMap);
     }
-    _checkIfCorrupted() {
-        for (const [key, arcInstance] of this._arcMap) {
-            const copyarc = this._arcMapTest.get(key);
-            if (!copyarc) {
-                console.warn(`Arc with key ${key} is missing in the test map.`);
-                continue;
-            }
-            if (!arc.equals(arcInstance, copyarc)) {
-                console.warn(`Arc with key ${key} is corrupted: p0 and p1 are the same point.`);
-            }
-        }
+    _buildStaticArc() {
     }
 }