@pirireis/webglobeplugins 0.15.26 → 0.15.28

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.15.26",
+    "version": "0.15.28",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT",

package/range-tools-on-terrain/circle-line-chain/plugin.js

@@ -185,8 +185,8 @@ export class CircleLineChainPlugin {
         for (const chainKey of chainKeys) {
             const keys = this._chainListMap.deleteChainAndReturnChainKeys(chainKey, this._textWritersMap);
             if (keys.length <= 1) {
-                console.warn("No chains were deleted, chainKeys might be invalid.");
-                return;
+                console.warn(`Deleted chain ${chainKey}, was too small to be displayed.`);
+                continue;
             }
             keys.pop(); // Remove the last key which which is destination of the last circle
             this.linePlugin?.deleteBulk(keys);
@@ -216,6 +216,11 @@ export class CircleLineChainPlugin {
             console.warn("CircleLineChainPlugin is freed, cannot update nodes properties.");
             return;
         }
+        const hasChain = this._chainListMap.hasChain(chainKey);
+        if (!hasChain) {
+            console.warn(`Chain with key ${chainKey} not found.`);
+            return;
+        }
         this._chainListMap.updateNodesProperties(chainKey, nodesAndPropertyList);
         this._cleanChainsFromSemiPlugins([chainKey]);
         this._reconstructChains([chainKey]);

package/range-tools-on-terrain/range-ring/enum.js

@@ -0,0 +1,2 @@
+export const ENUM_HIDE = Object.freeze({ SHOW: 0, HIDE: 1, HIDE_1_DEGREE_PADDINGS: 2 });
+export const ENUM_TEXT_HIDE = Object.freeze({ SHOW: 0, HIDE: 1 });

package/range-tools-on-terrain/range-ring/plugin.js

@@ -2,6 +2,8 @@ import { CircleOnTerrainPlugin } from "../../semiplugins/shape-on-terrain/circle
 import { ArcOnTerrainPlugin } from "../../semiplugins/shape-on-terrain/arc-plugin";
 import { Padding1DegreePlugin } from '../../semiplugins/shape-on-terrain/padding-1-degree';
 import { padding1DegreeInputAdapter, rangeRingToArcInputAdapter, rangeRingToCircleInputAdapter, allCircleKeysAdapter, allArcKeysAdapter, createColorRatios } from "./adapters";
+import RangeRingAngleText from "./rangeringangletext";
+import { opacityCheck } from "../../util/check/typecheck";
 export var ENUM_HIDE;
 (function (ENUM_HIDE) {
     ENUM_HIDE[ENUM_HIDE["SHOW"] = 0] = "SHOW";
@@ -24,40 +26,47 @@ export class RangeRingPlugin {
     _memory = new Map();
     _freed = false;
     textWritersMap = new Map();
+    rangeRingAngleText = null;
+    _opacity = 1;
+    _numbersStyle = null;
+    draw1degrePadding = true;
     _semiPluginOptions = {
         circleOnTerrainOptions: {
-            variativeColorsOn: false,
+            variativeColorsOn: true,
             defaultColor: [1, 1, 1, 1],
             defaultHeightFromGroundIn3D: 30,
         },
         arcOnTerrainOptions: {
             flatViewOn: true,
             globeViewOn: true,
-            variativeColorsOn: false,
+            variativeColorsOn: true,
             defaultColor: [1, 1, 1, 1],
             defaultHeightFromGroundIn3D: 0,
             vertexCount: 32,
             cameraAttractionIsOn: true // If true, camera attraction is enabled else evenly distributed arc points are used
         },
         paddingOptions: {
-            variativeColorsOn: false,
+            variativeColorsOn: true,
             defaultColor: [1, 1, 1, 1],
             defaultHeightFromGroundIn3D: 0,
+            adativePaddingSize: true,
         },
     };
     constructor(id, { textDataPreAdaptor = (center) => center, textWritersMap = new Map(), }) {
         this.id = id;
         this.circlePlugin = new CircleOnTerrainPlugin(this.id + "-circle", {
             variativeColorsOn: true,
+            ...this._semiPluginOptions.circleOnTerrainOptions
         });
         this.arcPlugin = new ArcOnTerrainPlugin(this.id + "-arc", {
             variativeColorsOn: true,
-            vertexCount: 20,
+            ...this._semiPluginOptions.arcOnTerrainOptions
         });
         this.paddingPlugin = new Padding1DegreePlugin(this.id + "-padding", {
             variativeColorsOn: true,
             defaultColor: [1, 1, 1, 1],
             defaultHeightFromGroundIn3D: 0,
+            ...this._semiPluginOptions.paddingOptions
         });
         if (textWritersMap) {
             this.textWritersMap = textWritersMap;
@@ -87,6 +96,7 @@ export class RangeRingPlugin {
                 this.updateText([item.centerID]);
             }
         }
+        this.rangeRingAngleText?.insertBulk(items);
     }
     removeCenters(centers) {
         if (this._freed) {
@@ -103,16 +113,20 @@ export class RangeRingPlugin {
                 console.warn(`No data found for centerID: ${centers[i]}`);
                 continue;
             }
+            this._memory.delete(centers[i]);
+            if (rangeRingInput.hide === ENUM_HIDE.HIDE) {
+                continue;
+            }
             const circleKeys = allCircleKeysAdapter(rangeRingInput);
             this.circlePlugin.deleteBulk(circleKeys);
-            this.paddingPlugin?.deleteBulk(circleKeys);
             const allArcKeys = allArcKeysAdapter(rangeRingInput);
             this.arcPlugin.deleteBulk(allArcKeys);
-            this._memory.delete(centers[i]);
+            if (rangeRingInput.hide !== ENUM_HIDE.HIDE_1_DEGREE_PADDINGS) {
+                this.paddingPlugin?.deleteBulk(circleKeys);
+            }
         }
         this.globe.DrawRender();
-    }
-    updateCenters() {
+        this.rangeRingAngleText?.removeCenters(centers);
     }
     updateCentersCoordinate(items) {
         if (this._freed) {
@@ -130,14 +144,20 @@ export class RangeRingPlugin {
             if (rangeRingInput) {
                 rangeRingInput.long = long;
                 rangeRingInput.lat = lat;
+                if (rangeRingInput.hide === ENUM_HIDE.HIDE) {
+                    continue;
+                }
                 const arcData = rangeRingToArcInputAdapter(globe, rangeRingInput);
                 this.arcPlugin.updateCoordinates(arcData);
                 const circleData = rangeRingToCircleInputAdapter(rangeRingInput);
                 this.circlePlugin.updateCoordinates(circleData);
-                this.paddingPlugin?.updateCoordinates(circleData);
+                if (rangeRingInput.hide !== ENUM_HIDE.HIDE_1_DEGREE_PADDINGS) {
+                    this.paddingPlugin?.updateCoordinates(circleData);
+                }
                 this.updateText([centerID]);
             }
         }
+        this.rangeRingAngleText?.updateCentersXY(items);
     }
     updateCentersColor(items) {
         if (this._freed) {
@@ -156,12 +176,15 @@ export class RangeRingPlugin {
                 continue;
             }
             data.rgba = item.rgba;
+            if (data.hide === ENUM_HIDE.HIDE) {
+                continue;
+            }
             // update arc Colors 
             const arcColors = allArcKeysAdapter(data).map(key => ({ key, color: data.rgba }));
             this.arcPlugin.updateColors(arcColors, false);
             const circleColors = allCircleKeysAdapter(data).map(key => ({ key, color: data.rgba }));
             this.circlePlugin.updateColors(circleColors);
-            if (this.paddingPlugin) {
+            if (this.paddingPlugin && data.hide !== ENUM_HIDE.HIDE_1_DEGREE_PADDINGS) {
                 const colorRatios = createColorRatios(data.rgba, data.stepAngle, 0.5);
                 for (const { key } of circleColors) {
                     this.paddingPlugin?.updateColorRatios(key, colorRatios, false);
@@ -171,7 +194,100 @@ export class RangeRingPlugin {
         }
         this.globe.DrawRender();
     }
-    updateCentersHide() {
+    updateCentersHide(items) {
+        if (this._freed) {
+            console.warn("Plugin is freed, cannot update centers hide");
+            return;
+        }
+        if (this.globe === null || this.gl === null) {
+            console.warn("Globe or WebGL context is not initialized, cannot update centers hide");
+            return;
+        }
+        console.log("updateCentersHide", items);
+        const globe = this.globe;
+        for (const item of items) {
+            const { centerID, hide, textHide } = item;
+            const rangeRingInput = this._memory.get(centerID);
+            if (!rangeRingInput) {
+                console.warn(`No data found for centerID: ${centerID}`);
+                continue;
+            }
+            if (textHide !== undefined) {
+                rangeRingInput.textHide = textHide;
+            }
+            // Update hide state first
+            if (hide !== undefined) {
+                if (rangeRingInput.hide !== hide) {
+                    if (hide === ENUM_HIDE.HIDE) {
+                        const circleKeys = allCircleKeysAdapter(rangeRingInput);
+                        this.circlePlugin.deleteBulk(circleKeys);
+                        if (rangeRingInput.hide !== ENUM_HIDE.HIDE_1_DEGREE_PADDINGS) {
+                            this.paddingPlugin?.deleteBulk(circleKeys);
+                        }
+                        const allArcKeys = allArcKeysAdapter(rangeRingInput);
+                        this.arcPlugin.deleteBulk(allArcKeys);
+                    }
+                    else {
+                        if (rangeRingInput.hide === ENUM_HIDE.SHOW && hide === ENUM_HIDE.HIDE_1_DEGREE_PADDINGS) {
+                            const paddingKeys = allCircleKeysAdapter(rangeRingInput);
+                            this.paddingPlugin?.deleteBulk(paddingKeys);
+                        }
+                        else if (rangeRingInput.hide !== ENUM_HIDE.SHOW && hide === ENUM_HIDE.SHOW) {
+                            const paddingData = padding1DegreeInputAdapter(rangeRingInput);
+                            this.paddingPlugin?.insertBulk(paddingData);
+                        }
+                        if (rangeRingInput.hide === ENUM_HIDE.HIDE) {
+                            const circleInputs = rangeRingToCircleInputAdapter(rangeRingInput);
+                            this.circlePlugin?.insertBulk(circleInputs);
+                            const arcInputs = rangeRingToArcInputAdapter(globe, rangeRingInput);
+                            this.arcPlugin?.insertBulk(arcInputs);
+                        }
+                    }
+                    rangeRingInput.hide = hide;
+                }
+            }
+            if (rangeRingInput.textHide === ENUM_TEXT_HIDE.HIDE || rangeRingInput.hide === ENUM_HIDE.HIDE) {
+                this.textWritersMap.forEach((writer) => writer.deleteText(rangeRingInput));
+            }
+            else if (rangeRingInput.textHide === ENUM_TEXT_HIDE.SHOW) {
+                this.textWritersMap.forEach((writer) => writer.insertText(rangeRingInput));
+            }
+        }
+        this.rangeRingAngleText?.updateCentersHide(items);
+        this.globe.DrawRender();
+    }
+    setOpacity(opacity) {
+        if (this._freed) {
+            console.warn("Plugin is freed, cannot set opacity");
+            return;
+        }
+        opacityCheck(opacity);
+        if (this._opacity === opacity) {
+            return;
+        }
+        this._opacity = opacity;
+        this.arcPlugin?.setPluginOpacity(opacity);
+        this.circlePlugin?.setPluginOpacity(opacity);
+        this.paddingPlugin?.setPluginOpacity(opacity);
+        this.textWritersMap.forEach((writer) => writer.setOpacity(opacity));
+        this.rangeRingAngleText?.setOpacity(opacity);
+        this.globe?.DrawRender();
+    }
+    setOneDegreePaddingOn(state) {
+        if (this._freed) {
+            console.warn("Plugin is freed, cannot set padding on");
+            return;
+        }
+        if (this.paddingPlugin === null) {
+            console.warn("Padding plugin is not initialized");
+            return;
+        }
+        if (typeof state !== "boolean") {
+            console.warn("Invalid state type, expected boolean");
+            return;
+        }
+        this.draw1degrePadding = state;
+        this.globe?.DrawRender();
     }
     init(globe, gl) {
         this.globe = globe;
@@ -179,6 +295,7 @@ export class RangeRingPlugin {
         this.circlePlugin.init(globe, gl);
         this.arcPlugin.init(globe, gl);
         this.paddingPlugin?.init(globe, gl);
+        this.rangeRingAngleText = new RangeRingAngleText(globe, this.id + "text", { style: this._numbersStyle, opacity: this._opacity });
     }
     draw3D() {
         if (this._freed) {
@@ -186,12 +303,17 @@ export class RangeRingPlugin {
             return;
         }
         this.arcPlugin.draw3D();
-        this.paddingPlugin?.draw3D();
         this.circlePlugin.draw3D();
+        if (this.draw1degrePadding) {
+            this.paddingPlugin?.draw3D();
+        }
         for (const [key, writer] of this.textWritersMap) {
             writer.draw();
         }
     }
+    setZAlphaOnDegreePadding(zAlphaOnDegreePadding) {
+        throw new Error("setZAlphaOnDegreePadding is deprecated");
+    }
     free() {
         if (this._freed) {
             console.warn("RangeRing Plugin is already freed");
@@ -201,6 +323,7 @@ export class RangeRingPlugin {
         this.circlePlugin.free();
         this.arcPlugin.free();
         this.paddingPlugin?.free();
+        this.rangeRingAngleText?.free();
     }
     updateText(centerIDs = null) {
         if (this._freed) {
@@ -218,6 +341,12 @@ export class RangeRingPlugin {
             const rangeRingData = this._memory.get(centerID);
             if (!rangeRingData)
                 continue;
+            if (rangeRingData.hide === ENUM_HIDE.HIDE) {
+                continue;
+            }
+            if (rangeRingData.textHide === ENUM_TEXT_HIDE.HIDE) {
+                continue;
+            }
             for (const [key, writer] of textWritersMap) {
                 writer.insertText(rangeRingData);
             }

package/range-tools-on-terrain/range-ring/rangeringangletext.js

@@ -0,0 +1,331 @@
+// @ts-ignore
+import { CSObjectArrayUpdateTypes } from "@pirireis/webglobe";
+import { ENUM_HIDE, ENUM_TEXT_HIDE } from "./enum";
+const fidKey = "__fid__";
+const object = {
+    "displayName": "RangeRingAngleText",
+    "layerType": 3,
+    "wkbGeom": null,
+    "wfsLayerName": null,
+    "objectType": "point",
+    "bbox": null,
+    "startLod": 2,
+    "endLod": 30,
+    "continuousLOD": true,
+    "MVTXYZName": "hd_seyp",
+    "rasterize": false,
+};
+export default class RangeRingAngleText {
+    globe;
+    ObjectArray;
+    id;
+    _hideAll;
+    _opacity;
+    object;
+    _centerCollection;
+    constructor(globe, id, { style = null, hideAll = false, opacity = 1 } = {}) {
+        this.globe = globe;
+        this.ObjectArray = globe.ObjectArray;
+        this.id = id;
+        this._hideAll = hideAll;
+        this._opacity = opacity;
+        const style_ = style !== null ? style : this.getDefaultStyle();
+        this.object = Object.assign({}, object, { style: style_, id: this.id });
+        this._centerCollection = new Map();
+        // new inner MAP params
+        // hide
+        // textHide
+        this.ObjectArray.Add(this.object);
+    }
+    getDefaultStyle() {
+        const style = this.ObjectArray.GetDefaultStyle();
+        style.fidKey = fidKey;
+        const { labels } = style;
+        const label = labels[0];
+        label.offset = { x: 0, y: 0 };
+        label.fontFamily.hollowWidth = 1;
+        label.vAlignment = 2;
+        label.hAlignment = 2;
+        label.size = 17;
+        // eslint-disable-next-line
+        label.text = "`${aci}`";
+        return style;
+    }
+    setStyle(style) {
+        if (style === null)
+            return;
+        style.opacity = this._opacity;
+        this.object.style = style;
+        this.ObjectArray.StyleChanged(this.object);
+    }
+    setOpacity(opacity) {
+        this._opacity = opacity;
+        const { style } = this.object;
+        style.opacity = opacity;
+        this.ObjectArray.StyleChanged(this.object);
+    }
+    free() {
+        this.flush();
+        this.ObjectArray.Delete(this.id);
+    }
+    /**
+     * @param ringDatas Array of ring data objects
+     * centerID: string | ObjectArray fidKey de kullanilir
+     * stepAngle: number | 0-360 arasinda
+     * long,lat: number | merkez koordinatlari lat long radian. Globe icin dereceye iceride cevrilir
+     * rings: Array<{radius: number}> | En buyuk halkaya centik acilari yazilir, Sonraki adim yaricaplarin uzunlugunu yazdirmak
+     *
+     * eger bir centerID zaten var ise: Onceki noktalar dusurulur ve yeniden eklenir
+     */
+    insertBulk(ringDatas) {
+        const { _hideAll } = this;
+        const addBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        const deleteBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const { centerID, long, lat, rings, stepAngle, hide = ENUM_HIDE.SHOW, textHide = ENUM_TEXT_HIDE.SHOW } of ringDatas) {
+            if (this._centerCollection.has(centerID)) {
+                this._fillDeleteBucket(centerID, deleteBucket);
+            }
+            const maxRadius = rings.reduce((acc, { radius }) => Math.max(acc, radius), 0);
+            const textHide_ = _hideAll ? ENUM_TEXT_HIDE.HIDE : textHide;
+            const show = hide !== ENUM_HIDE.HIDE && textHide_ === ENUM_TEXT_HIDE.SHOW;
+            if (show)
+                this._appendCircle(long, lat, maxRadius, stepAngle, centerID, addBucket);
+            this._centerCollection.set(centerID, new Map([
+                ["stepAngle", stepAngle],
+                ["maxRadius", maxRadius],
+                ["long", long],
+                ["lat", lat],
+                ["hide", hide],
+                ["textHide", textHide_]
+            ]));
+        }
+        if (this._hideAll)
+            return;
+        if (deleteBucket.coords.length > 0)
+            this._updateData(deleteBucket, CSObjectArrayUpdateTypes.DELETE);
+        if (addBucket.coords.length > 0)
+            this._updateData(addBucket, CSObjectArrayUpdateTypes.ADD);
+    }
+    /**
+     * @param centerDatas Array of center data objects
+     * aci ve radiuslarin tutulmasi gereklidir.
+     */
+    updateCentersXY(centerDatas) {
+        const updateBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const { centerID, long, lat } of centerDatas) {
+            if (this._centerCollection.has(centerID)) {
+                const centerMap = this._centerCollection.get(centerID);
+                centerMap.set("long", long);
+                centerMap.set("lat", lat);
+                const hide = centerMap.get("hide");
+                const textHide = centerMap.get("textHide");
+                const isHidden = hide === ENUM_HIDE.HIDE || textHide === ENUM_TEXT_HIDE.HIDE;
+                if (isHidden)
+                    continue;
+                const maxRadius = centerMap.get("maxRadius");
+                const stepAngle = centerMap.get("stepAngle");
+                // long, lat, radius, step, centerID, outBucket
+                this._appendCircle(long, lat, maxRadius, stepAngle, centerID, updateBucket);
+            }
+        }
+        // for (const attribs of updateBucket.attribs) {
+        //     delete attribs["aci"];
+        // }
+        if (updateBucket.coords.length > 0) {
+            this._updateData(updateBucket, CSObjectArrayUpdateTypes.UPDATE);
+        }
+    }
+    /**
+     * @param centerHides Array of center hide data
+     */
+    updateCentersHide(centerHides) {
+        if (this._hideAll) {
+            console.warn("Tum mesafe halkasi yazilari gizli durum. Islem yapilamaz");
+            return;
+        }
+        ;
+        const addBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        const deleteBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const { centerID, textHide = null, hide = null } of centerHides) {
+            if (!this._centerCollection.has(centerID))
+                continue;
+            const centerMap = this._centerCollection.get(centerID);
+            const isHidden = centerMap.get("hide") === ENUM_HIDE.HIDE || centerMap.get("textHide") === ENUM_TEXT_HIDE.HIDE;
+            const _hide = hide !== null ? hide : centerMap.get("hide");
+            const _textHide = textHide !== null ? textHide : centerMap.get("textHide");
+            const show = (_hide !== ENUM_HIDE.HIDE) && (_textHide === ENUM_TEXT_HIDE.SHOW);
+            if (!isHidden && !show) {
+                this._fillDeleteBucket(centerID, deleteBucket);
+            }
+            else if (isHidden && show) {
+                this._appendCircle(centerMap.get("long"), centerMap.get("lat"), centerMap.get("maxRadius"), centerMap.get("stepAngle"), centerID, addBucket);
+            }
+            if (hide !== null)
+                centerMap.set("hide", hide);
+            if (textHide !== null)
+                centerMap.set("textHide", textHide);
+        }
+        if (deleteBucket.coords.length > 0)
+            this._updateData(deleteBucket, CSObjectArrayUpdateTypes.DELETE);
+        if (addBucket.coords.length > 0)
+            this._updateData(addBucket, CSObjectArrayUpdateTypes.ADD);
+    }
+    // TODO : Implement this
+    removeCenters(centerIDs) {
+        const deleteBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const centerID of centerIDs) {
+            if (this._centerCollection.has(centerID)) {
+                this._fillDeleteBucket(centerID, deleteBucket);
+                this._centerCollection.delete(centerID);
+            }
+        }
+        this._updateData(deleteBucket, CSObjectArrayUpdateTypes.DELETE);
+    }
+    hideAll() {
+        this._hideAll = true;
+        const deleteBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const [centerID, centerMap] of this._centerCollection) {
+            const hide = centerMap.get("hide");
+            const hideText = centerMap.get("textHide");
+            centerMap.set("textHide", ENUM_TEXT_HIDE.HIDE);
+            if (hide === ENUM_HIDE.HIDE)
+                continue;
+            const isHidden = hideText === ENUM_TEXT_HIDE.HIDE;
+            if (!isHidden)
+                this._fillDeleteBucket(centerID, deleteBucket);
+        }
+        this._updateData(deleteBucket, CSObjectArrayUpdateTypes.DELETE);
+    }
+    showAll() {
+        this._hideAll = false;
+        const addBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const [centerID, centerMap] of this._centerCollection) {
+            const hide = centerMap.get("hide");
+            if (hide === ENUM_HIDE.HIDE)
+                continue;
+            const hideText = centerMap.get("textHide");
+            const isHidden = hideText === ENUM_TEXT_HIDE.HIDE;
+            if (isHidden) {
+                const long = centerMap.get("long");
+                const lat = centerMap.get("lat");
+                const maxRadius = centerMap.get("maxRadius");
+                const stepAngle = centerMap.get("stepAngle");
+                this._appendCircle(long, lat, maxRadius, stepAngle, centerID, addBucket);
+                centerMap.set("hide", ENUM_HIDE.SHOW);
+                centerMap.set("textHide", ENUM_TEXT_HIDE.SHOW);
+            }
+        }
+        if (addBucket.coords.length)
+            this._updateData(addBucket, CSObjectArrayUpdateTypes.ADD);
+    }
+    flush() {
+        const data = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        this.ObjectArray.SetData(this.object, data);
+    }
+    //------------------PRIVATE METHODS------------------//
+    _appendCircle(long, lat, radius, step, centerID, outBucket) {
+        this.__realCoords(long, lat, radius, step, centerID, outBucket);
+    }
+    __realCoords(longCenter, latCenter, radius, stepAngle, centerID, outBucket) {
+        const { globe } = this;
+        const { coords, coordsZ, attribs } = outBucket;
+        let i = 1;
+        for (let aci = stepAngle; aci < 360; aci += stepAngle) {
+            const { long, lat } = globe.Math.FindPointByPolar(longCenter, latCenter, radius, aci);
+            coords.push(long, lat);
+            coordsZ.push(0);
+            const key = this._key(centerID, i);
+            i++;
+            // fidkey is the key
+            attribs.push({
+                "__fid__": key,
+                "aci": (aci).toFixed(0).toString().padStart(3, '0')
+            });
+        }
+        { // add 0
+            const { long, lat } = globe.Math.FindPointByPolar(longCenter, latCenter, radius, 0);
+            coords.push(long, lat);
+            coordsZ.push(0);
+            const key = this._key(centerID, 0);
+            // fidkey is the key
+            attribs.push({
+                "__fid__": key,
+                "aci": "K"
+            });
+        }
+    }
+    _updateData(bucket, mode) {
+        this.ObjectArray.UpdateData(this.object, mode, [bucket], { attribs: false, icon: false, text: false });
+    }
+    _key(centerRingKey, limpIndex) {
+        return `${centerRingKey}_${limpIndex}`;
+    }
+    _fillDeleteBucket(centerID, outDeleteBucket) {
+        const centerMap = this._centerCollection.get(centerID);
+        const stepAngle = centerMap.get("stepAngle");
+        const { coords, coordsZ, attribs } = outDeleteBucket;
+        let i = 0;
+        for (let aci = 0; aci < 360; aci += stepAngle) {
+            const key = this._key(centerID, i++);
+            coords.push(0, 0);
+            coordsZ.push(0);
+            attribs.push({
+                "__fid__": key,
+            });
+        }
+    }
+    _updateAll() {
+        const updateBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const [centerID, centerMap] of this._centerCollection) {
+            const isHidden = centerMap.get("hide") === ENUM_HIDE.HIDE || centerMap.get("textHide") === ENUM_TEXT_HIDE.HIDE;
+            if (isHidden)
+                continue;
+            const long = centerMap.get("long");
+            const lat = centerMap.get("lat");
+            const maxRadius = centerMap.get("maxRadius");
+            const stepAngle = centerMap.get("stepAngle");
+            this._appendCircle(long, lat, maxRadius, stepAngle, centerID, updateBucket);
+        }
+        this._updateData(updateBucket, CSObjectArrayUpdateTypes.UPDATE);
+    }
+}

package/rangerings/enum.js

@@ -1,2 +1 @@
-export const ENUM_HIDE = Object.freeze({ SHOW: 0, HIDE: 1, HIDE_1_DEGREE_PADDINGS: 2 });
-export const ENUM_TEXT_HIDE = Object.freeze({ SHOW: 0, HIDE: 1 });
+"use strict";

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

@@ -348,6 +348,10 @@ export class CircleOnTerrainPlugin {
             const [{ radius, center, height = null, msl = null }, circleForAzimuthCalc] = this.circleMap.get(key);
             const closestAzimuthAngle = CircleMethods.closestAzimuthAngle(circleForAzimuthCalc, cameraPosition);
             const stregthLevel = defineStregthLevel(currentLOD, radius);
+            if (typeof stregthLevel !== "number") {
+                console.warn(`CircleOnTerrainPlugin: Circle ${key} has invalid strength level for current LOD ${currentLOD}. Skipping., radius: ${radius}, stregthLevel: ${stregthLevel}`);
+                continue;
+            }
             if (stregthLevel < 0) {
                 console.warn(`CircleOnTerrainPlugin: Circle ${key} has too small radius for current LOD ${currentLOD}. Skipping., radius: ${radius}, stregthLevel: ${stregthLevel}`);
                 continue;

package/semiplugins/shape-on-terrain/padding-1-degree.js

@@ -162,6 +162,9 @@ export class Padding1DegreePlugin {
             return;
         }
         this.bufferOrchestrator.deleteBulk(keys, this.bufferManagerMap);
+        for (const key of keys) {
+            this._dataMap.delete(key);
+        }
         this.globe?.DrawRender();
     }
     setPluginOpacity(opacity, drawRender = false) {
@@ -414,7 +417,6 @@ export class Padding1DegreePlugin {
     }
     __inner(subSetIDs = null) {
         // Implement inner circle padding logic
-        console.log("innerCircle Level Update");
         const datas = this._dataMap;
         let keys;
         if (subSetIDs) {

package/write-text/context-text4.js

@@ -90,7 +90,7 @@ export class ContextTextWriter4 {
         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 { lat, long, text, opacity = null, angle = null, zPayload, anchor } = item;
             const { x, y } = globe.api_GetScreenPointFromGeo({
                 long: long,
                 lat: lat,
@@ -99,7 +99,7 @@ export class ContextTextWriter4 {
             const { opacityMultiplier, sizeMultiplier } = zoomAdaptor(zPayload);
             const o = (opacity === null ? opacity_ : opacity * opacity_) * opacityMultiplier;
             textFont.size = sizeMultiplier * textSize;
-            textFont.position = position;
+            textFont.position = anchor;
             if (x !== null && y !== null)
                 globe.api_DrawContextTextMultiLine(text, textFont, o, { x: x + xOffset, y: y - yOffset }, angleIsOn, angle);
         }
@@ -117,9 +117,11 @@ export class ContextTextWriter4 {
         }
     }
     deleteText(data) {
-        const key = this.deleteAdaptor ? this.deleteAdaptor(data) : data;
-        if (this.itemMap.has(key)) {
-            this.itemMap.delete(key);
+        const keys = this.deleteAdaptor(data);
+        for (const key of keys) {
+            if (this.itemMap.has(key)) {
+                this.itemMap.delete(key);
+            }
         }
     }
     deleteTextBulk(datas) {