@pirireis/webglobeplugins 0.15.2-3.alpha → 0.15.3-alpha

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

@@ -7,7 +7,6 @@ import { globe3Dcoordinates, globe2Dcoordinates, RADIANS } from "../../Math/meth
 import { generateArcPoints, evenlySpacedArcPoints } from "../../Math/arc-cdf-points";
 import { StaticDynamicState, StaticDynamicStrategy } from "../../util/build-strategy/static-dynamic";
 import { opacityCheck } from "../../util/check/typecheck";
-import { FrameCounterTrigger } from "../../util/frame-counter-trigger";
 import * as vec3 from "../../Math/vec3";
 import * as arc from "../../Math/arc";
 import { CameraUniformBlockTotemCache } from "../../programs/totems/camerauniformblock";
@@ -18,16 +17,11 @@ 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
-function createArc(start, end) {
-    vec3.fromLongLatToUnitVector(_start, [start[0] * RADIANS, start[1] * RADIANS]);
-    vec3.fromLongLatToUnitVector(_end, [end[0] * RADIANS, end[1] * RADIANS]);
-    return arc.create(_start, _end);
-}
 export class ArcOnTerrainPlugin {
     id;
     program = null;
-    bufferManagersMap = null;
-    bufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
+    bufferManagerMap = null;
+    _bufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
     _opacity = 1;
     _arcUBOHandler = null;
     _vao = null;
@@ -39,14 +33,13 @@ export class ArcOnTerrainPlugin {
     _options;
     _coordinaateBufferKeysForUpdate = [];
     _freed = false;
-    _frameCounterTrigger = null;
     constructor(id, { globeViewOn = true, // If true, arcs are drawn in 3D globe view
     flatViewOn = true, // If true, arcs are drawn in 2D flat view
     variativeColorsOn = false, defaultColor = [0.1, 0.1, 1, 1], // Default color in RGBA format
     defaultHeightFromGroundIn3D = 30.0, // Default height from ground in
     vertexCount = 70, // Number of vertices per arc
-    cameraAttractionIsOn = true, // If true, camera attraction is enabled else evenly distributed arc points are used
-    bufferType = "STREAM_DRAW", isMSL = false } = {}) {
+    cameraAttractionIsOn = true // If true, camera attraction is enabled else evenly distributed arc points are used
+     } = {}) {
         this.id = id;
         this._arcMap = new Map();
         this._options = {
@@ -56,74 +49,27 @@ export class ArcOnTerrainPlugin {
             defaultColor: defaultColor ? defaultColor : [0.1, 0.1, 1, 1],
             defaultHeightFromGroundIn3D: defaultHeightFromGroundIn3D ? defaultHeightFromGroundIn3D : 30.0,
             vertexCount: vertexCount ? vertexCount : 70,
-            cameraAttractionIsOn: cameraAttractionIsOn ? true : false,
-            bufferType: bufferType ? bufferType : "STREAM_DRAW",
-            isMSL: isMSL ? true : false
+            cameraAttractionIsOn: cameraAttractionIsOn ? true : false
         };
     }
-    increaseSpace(amount) {
-        if (this._freed) {
-            console.warn("Plugin is freed, cannot increase space");
-            return;
-        }
-        if (this.globe === null) {
-            console.warn("Globe is not initialized.");
-            return;
-        }
-        if (typeof amount !== "number" || amount <= 0) {
-            console.warn("Invalid amount, must be a positive number");
-            return;
-        }
-        this.bufferOrchestrator.ensureSpace(amount, this.bufferManagersMap);
-    }
     insertBulk(arcs) {
         const keys = [];
-        let newItemCount = 0;
         for (let arcInput of arcs) {
             const { key, start, end } = arcInput;
             if (this._arcMap.has(key)) {
-                this._arcMap.delete(key); // Remove old arc
-            }
-            else {
-                newItemCount++;
+                this._arcMap.delete(key);
             }
-            const _arc = createArc(start, end);
-            this._arcMap.set(key, [_arc, arcInput]); // Always set new color
+            vec3.fromLongLatToUnitVector(_start, [start[0] * RADIANS, start[1] * RADIANS]);
+            vec3.fromLongLatToUnitVector(_end, [end[0] * RADIANS, end[1] * RADIANS]);
+            const _arc = arc.create(_start, _end);
+            this._arcMap.set(key, [_arc, arcInput]); // height is null for now
             keys.push(key);
         }
-        this.bufferOrchestrator.ensureSpace(newItemCount, this.bufferManagersMap);
-        this._buildArcs(keys);
-        if (this._options.variativeColorsOn) {
-            this.__fillColors(keys);
-        }
-        this.globe.DrawRender();
-    }
-    updateCoordinates(items) {
-        if (this._freed) {
-            console.warn("Plugin is freed, cannot update coordinates");
-            return;
-        }
-        if (this.globe === null || this.gl === null) {
-            console.warn("Globe or WebGL context is not initialized, cannot update coordinates");
-            return;
-        }
-        const updateKeys = [];
-        for (const { key, start, end } of items) {
-            const arcInput = this._arcMap.get(key);
-            if (!arcInput) {
-                console.warn(`Arc with key ${key} not found in arcMap.`);
-                continue;
-            }
-            const _arc = createArc(start, end);
-            arc.copy(arcInput[0], _arc); // Update the arc in the map
-            // Update the arc in the buffer
-            updateKeys.push(key);
-        }
-        this._buildArcs(updateKeys);
+        this.__buildStaticArcs(keys, true);
         this.globe.DrawRender();
     }
     deleteBulk(keys) {
-        if (!this.bufferOrchestrator || !this.bufferManagersMap || !this.globe) {
+        if (!this._bufferOrchestrator || !this.bufferManagerMap || !this.globe) {
             console.warn("Buffer orchestrator or buffer manager map is not initialized.");
             return;
         }
@@ -135,70 +81,44 @@ export class ArcOnTerrainPlugin {
                 console.warn(`Arc with key ${key} not found in arcMap.`);
             }
         }
-        this.bufferOrchestrator.deleteBulk(keys, this.bufferManagersMap);
+        this._bufferOrchestrator.deleteBulk(keys, this.bufferManagerMap);
         this.globe.DrawRender();
     }
-    updateColors(keyColorCouples, drawRender = true) {
-        if (this._freed) {
-            console.warn("Plugin is freed, cannot update color");
-            return;
-        }
+    updateColor(key, color) {
         if (this._options.variativeColorsOn === false) {
             console.warn("Variative colors are not enabled in this plugin. Create another instance with variativeColorsOn: true to use this feature.");
             return;
         }
-        const { bufferOrchestrator, bufferManagersMap } = this;
-        if (!bufferOrchestrator || !bufferManagersMap) {
+        const { _bufferOrchestrator, bufferManagerMap } = this;
+        if (!_bufferOrchestrator || !bufferManagerMap) {
             console.warn("Buffer orchestrator or buffer manager map is not initialized.");
             return;
         }
-        for (const { key, color } of keyColorCouples) {
-            const arcInput = this._arcMap.get(key);
-            if (!arcInput) {
-                console.warn(`Arc with key ${key} not found in arcMap.`);
-                return;
-            }
-            arcInput[1].color = color; // Update the color in the arc map
-            bufferOrchestrator.updateBulk([{ key: key, color: color }], bufferManagersMap, ["color"]);
-        }
-        if (drawRender) {
-            this.globe.DrawRender();
+        const arcInput = this._arcMap.get(key);
+        if (!arcInput) {
+            console.warn(`Arc with key ${key} not found in arcMap.`);
+            return;
         }
+        arcInput[1].color = color; // Update the color in the arc map
+        _bufferOrchestrator.updateBulk([{ key: key, color: color }], bufferManagerMap, ["color"]);
+        this.globe.DrawRender();
     }
-    setPluginOpacity(opacity, drawRender = false) {
+    setPluginOpacity(opacity) {
         if (!this.globe || !this.gl) {
             console.warn("Globe or WebGL context is not initialized.");
             return;
         }
         opacityCheck(opacity);
         this._opacity = opacity;
-        if (drawRender) {
-            this.globe.DrawRender();
-        }
+        this.globe.DrawRender();
     }
-    setDefaultColor(color, drawRender = false) {
+    setDefaultColor(color) {
         if (!this.globe || !this.gl) {
             console.warn("Globe or WebGL context is not initialized.");
             return;
         }
         this._options.defaultColor = color;
         this._arcUBOHandler?.updateSingle("u_color", new Float32Array(color));
-        if (drawRender) {
-            this.globe.DrawRender();
-        }
-    }
-    setElevationMode(mode) {
-        switch (mode) {
-            case "msl":
-                this._options.isMSL = true;
-                break;
-            case "agl":
-                this._options.isMSL = false;
-                break;
-            default:
-                throw new Error(`Unknown elevation mode: ${mode}`);
-        }
-        this._buildArcs(); // can be async
         this.globe.DrawRender();
     }
     setCameraAttraction(isOn) {
@@ -212,18 +132,11 @@ export class ArcOnTerrainPlugin {
     init(globe, gl) {
         this.globe = globe;
         this.gl = gl;
-        this._frameCounterTrigger = new FrameCounterTrigger(globe, 15, 1000, (globeChanges) => {
-            if (this._freed)
-                return;
-            this.__buildDynamicArcs();
-        });
         this.program = LineStripProgramCache.get(globe);
-        this._staticDynamicStrategy = new StaticDynamicStrategy(globe, DYNAMIC_STRATEGY_START_LOD, () => {
-            this.__buildStaticArcs();
-        }); // Initialize static-dynamic strategy with a transition level of 8
+        this._staticDynamicStrategy = new StaticDynamicStrategy(globe, DYNAMIC_STRATEGY_START_LOD); // Initialize static-dynamic strategy with a transition level of 8
         this._cameraUniformBlock = CameraUniformBlockTotemCache.get(globe);
-        this._fillbufferManagersMap();
-        this.bufferOrchestrator = new BufferOrchestrator();
+        this._fillBufferManagerMap();
+        this._bufferOrchestrator = new BufferOrchestrator();
         this._arcUBOHandler = this.program.createUBO();
         this._arcUBOHandler.update(new Map([
             ["u_color", new Float32Array(this._options.defaultColor)],
@@ -235,49 +148,39 @@ export class ArcOnTerrainPlugin {
             console.warn("Globe or WebGL context is not initialized.");
             return;
         }
-        const globe = this.globe;
         this._staticDynamicStrategy?.updateState();
-        // if (globe.api_IsScreenMoving()) {
-        // this._buildArcs(); // can be async
-        // }
-        this._frameCounterTrigger?.trigger();
-        const { gl, program, bufferOrchestrator, _vao, _arcUBOHandler, } = this;
-        if (!gl || !program || !bufferOrchestrator || !_vao || !_arcUBOHandler) {
+        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 currentGeometry = globe.api_GetCurrentGeometry();
-        if ((currentGeometry === 0 && !this._options.globeViewOn) || (currentGeometry === 1 && !this._options.flatViewOn))
-            return;
         const drawOptions = {
             drawRange: {
                 first: 0,
-                count: bufferOrchestrator.length * (this._options.vertexCount + 1)
+                count: _bufferOrchestrator.length * (this._options.vertexCount + 1)
             },
             indexes: null
         };
         program.draw(_vao, drawOptions, this._opacity, _arcUBOHandler);
         gl.enable(gl.DEPTH_TEST);
     }
-    _buildArcs(subSetIDs = null) {
+    _buildArcs() {
         const state = this._staticDynamicStrategy?.getState();
-        if (state === StaticDynamicState.DYNAMIC) {
-            this.__buildDynamicArcs(subSetIDs);
+        if (state === StaticDynamicState.TO_STATIC) {
+            this.__buildStaticArcs();
         }
-        else if (subSetIDs || state === StaticDynamicState.TO_STATIC) {
-            this.__buildStaticArcs(subSetIDs);
+        else if (state === StaticDynamicState.DYNAMIC) {
+            this.__buildArcs();
         }
     }
-    __buildStaticArcs(subSetIDs = null) {
-        const { globe, _arcMap, _cameraUniformBlock, bufferManagersMap, bufferOrchestrator } = this;
-        if (!globe || !_cameraUniformBlock || !bufferManagersMap || !bufferOrchestrator) {
+    __buildStaticArcs(keys = [], calledFromInsert = false) {
+        const { globe, _arcMap, _cameraUniformBlock, bufferManagerMap, _bufferOrchestrator } = this;
+        if (!globe || !_cameraUniformBlock || !bufferManagerMap || !_bufferOrchestrator) {
             console.warn("Globe or camera uniform block is not initialized.");
             return;
         }
-        const bufferKey = [this.globe.api_GetCurrentGeometry() === 0 ? "position3d" : "position2d"];
-        if (!this.bufferManagersMap?.has(bufferKey[0]))
-            return;
         const longLat = [0, 0];
         const _attractionStrength = 0;
         const longLatArr = new Float32Array(2 * this._options.vertexCount);
@@ -285,43 +188,60 @@ export class ArcOnTerrainPlugin {
                 key: "staticArcs",
                 longLatArr: longLatArr,
                 height: null,
-                color: this._options.defaultColor,
-                msl: null
+                color: this._options.defaultColor
             }];
-        let keys;
-        if (subSetIDs === null) {
-            keys = _arcMap.keys();
+        if (keys.length == 0) {
+            for (const [key, [arcInstance, arcInput]] of _arcMap) {
+                arc.copy(_0arc, arcInstance);
+                const generatedPoints = evenlySpacedArcPoints(_0arc.p0, _0arc.normal, _0arc.coverAngle, this._options.vertexCount);
+                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 = arcInput.height ?? this._options.defaultHeightFromGroundIn3D;
+                data[0].color = arcInput.color ?? this._options.defaultColor;
+                if (calledFromInsert) {
+                    this._bufferOrchestrator.insertBulk(data, bufferManagerMap);
+                }
+                else {
+                    this._bufferOrchestrator.updateBulk(data, bufferManagerMap, this._coordinaateBufferKeysForUpdate);
+                }
+            }
         }
         else {
-            keys = subSetIDs;
-        }
-        for (const key of keys) {
-            const [arcInstance, arcInput] = _arcMap.get(key);
-            arc.copy(_0arc, arcInstance);
-            const generatedPoints = evenlySpacedArcPoints(_0arc.p0, _0arc.normal, _0arc.coverAngle, this._options.vertexCount);
-            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);
+            for (let key of keys) {
+                if (!_arcMap.has(key)) {
+                    console.warn(`Arc with key ${key} not found in arcMap.`);
+                    continue;
+                }
+                const [arcInstance, arcInput] = _arcMap.get(key);
+                arc.copy(_0arc, arcInstance);
+                const generatedPoints = evenlySpacedArcPoints(_0arc.p0, _0arc.normal, _0arc.coverAngle, this._options.vertexCount);
+                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 = arcInput.height ?? this._options.defaultHeightFromGroundIn3D;
+                data[0].color = arcInput.color ?? this._options.defaultColor;
+                if (calledFromInsert) {
+                    this._bufferOrchestrator.insertBulk(data, bufferManagerMap);
+                }
+                else {
+                    this._bufferOrchestrator.updateBulk(data, bufferManagerMap, this._coordinaateBufferKeysForUpdate);
+                }
             }
-            data[0].key = key;
-            data[0].height = arcInput.height ?? this._options.defaultHeightFromGroundIn3D;
-            data[0].color = arcInput.color ?? this._options.defaultColor;
-            data[0].msl = arcInput.msl ?? null;
-            this.bufferOrchestrator.insertBulk(data, bufferManagersMap, bufferKey);
         }
     }
-    __buildDynamicArcs(subSetIDs = null) {
-        const { globe, _arcMap, _cameraUniformBlock, bufferManagersMap } = this;
-        if (!globe || !_cameraUniformBlock || !bufferManagersMap) {
+    __buildArcs() {
+        const { globe, _arcMap, _cameraUniformBlock, bufferManagerMap } = this;
+        if (!globe || !_cameraUniformBlock || !bufferManagerMap) {
             console.warn("Globe or camera uniform block is not initialized.");
             return;
         }
-        const bufferKey = [
-            this.globe.api_GetCurrentGeometry() === 0 ? "position3d" : "position2d"
-        ];
-        if (!this.bufferManagersMap?.has(bufferKey[0]))
-            return;
         const { cameraAttractionIsOn } = this._options;
         const lookAtPosition = _cameraUniformBlock.getLookAtVector();
         const cameraPosition = _cameraUniformBlock.getCameraVector();
@@ -339,15 +259,7 @@ export class ArcOnTerrainPlugin {
         })();
         const result = [];
         const longLat = [0, 0];
-        let keys;
-        if (subSetIDs === null) {
-            keys = _arcMap.keys();
-        }
-        else {
-            keys = subSetIDs;
-        }
-        for (const key of keys) {
-            const [arcInstance, arcInput] = _arcMap.get(key);
+        for (const [key, [arcInstance, arcInput]] of _arcMap) {
             arc.copy(_0arc, arcInstance);
             const isOnArc = arc.closestPoint(_attractionPoint, _0arc, cameraPosition);
             if (!isOnArc) {
@@ -371,13 +283,13 @@ export class ArcOnTerrainPlugin {
                 key: key,
                 longLatArr: longLatArr,
                 height: arcInput.height ?? this._options.defaultHeightFromGroundIn3D,
-                msl: arcInput.msl ?? null
+                // color: arcInput.color // Use the color from the arc map
             });
         }
-        // this.bufferOrchestrator.resetWithCapacity(bufferManagersMap, result.length);
-        this.bufferOrchestrator.insertBulk(result, bufferManagersMap, bufferKey);
+        // this._bufferOrchestrator.resetWithCapacity(bufferManagerMap, result.length);
+        this._bufferOrchestrator.insertBulk(result, bufferManagerMap, ["position3d", "position2d"]);
     }
-    _fillbufferManagersMap() {
+    _fillBufferManagerMap() {
         const { gl, globe } = this;
         if (!gl || !globe) {
             console.warn("WebGL context or globe is not initialized.");
@@ -385,19 +297,19 @@ export class ArcOnTerrainPlugin {
         }
         const g2D = globe2Dcoordinates(globe);
         const { flatViewOn, globeViewOn, variativeColorsOn } = this._options;
-        this.bufferManagersMap = new Map();
+        this.bufferManagerMap = new Map();
         if (globeViewOn) {
-            this.bufferManagersMap.set("position3d", {
+            this.bufferManagerMap.set("position3d", {
                 bufferManager: new BufferManager(gl, 3 * (this._options.vertexCount + 1), { bufferType: "STREAM_DRAW", initialCapacity: INITAL_CAPACITY }),
                 adaptor: (item) => {
-                    const { longLatArr, height = this._options.defaultHeightFromGroundIn3D, msl = this._options.isMSL } = item;
-                    const result = globe3Dcoordinates(globe, longLatArr, height, msl, { paddingCount: 1 });
+                    const { longLatArr, height = this._options.defaultHeightFromGroundIn3D } = item;
+                    const result = globe3Dcoordinates(globe, height)(longLatArr, { paddingCount: 1 });
                     return result;
                 }
             });
         }
         if (flatViewOn) {
-            this.bufferManagersMap.set("position2d", {
+            this.bufferManagerMap.set("position2d", {
                 bufferManager: new BufferManager(gl, 2 * (this._options.vertexCount + 1), { bufferType: "STREAM_DRAW", initialCapacity: INITAL_CAPACITY }),
                 adaptor: (item) => {
                     const { longLatArr } = item;
@@ -406,8 +318,8 @@ export class ArcOnTerrainPlugin {
             });
         }
         if (this._options.variativeColorsOn) {
-            const _colorArray = new Float32Array(4 * (this._options.vertexCount + 1)); // TODO: this could cause data races or unexpected overwrites.
-            this.bufferManagersMap.set("color", {
+            const _colorArray = new Float32Array(4 * (this._options.vertexCount + 1));
+            this.bufferManagerMap.set("color", {
                 bufferManager: new BufferManager(gl, 4 * (this._options.vertexCount + 1), { bufferType: "STREAM_DRAW", initialCapacity: INITAL_CAPACITY }),
                 adaptor: (item) => {
                     // Calculate color based on radius
@@ -432,7 +344,7 @@ export class ArcOnTerrainPlugin {
                 return null;
             this._coordinaateBufferKeysForUpdate.push(key);
             // @ts-ignore
-            const bufferManager = this.bufferManagersMap.get(key).bufferManager;
+            const bufferManager = this.bufferManagerMap.get(key).bufferManager;
             // @ts-ignore
             return createBufferAndReadInfo(bufferManager.buffer);
         });
@@ -442,15 +354,6 @@ export class ArcOnTerrainPlugin {
         bufferObjects[2] // color
         );
     }
-    __fillColors(subSetIDs) {
-        if (this._options.variativeColorsOn === false)
-            return;
-        const data = [null];
-        for (const id of subSetIDs) {
-            data[0] = this._arcMap.get(id)[1];
-            this.bufferOrchestrator.insertBulk(data, this.bufferManagersMap, ["color"]);
-        }
-    }
     free() {
         if (this._freed) {
             console.warn("Plugin already freed");
@@ -461,7 +364,7 @@ export class ArcOnTerrainPlugin {
             return;
         }
         this._arcUBOHandler?.free();
-        this.bufferManagersMap?.forEach((manager) => {
+        this.bufferManagerMap?.forEach((manager) => {
             manager.bufferManager.free();
         });
         CameraUniformBlockTotemCache.release(this.globe);