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

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

@@ -19,15 +19,149 @@ export class BufferOrchestrator {
         this.tombstoneOffsets = [];
         this._length = 0;
     }
+    // ...existing code...
+    // TODO: CLEAN THIS
+    // insertBulk2(items: any[], bufferManagersMap: BufferManagersMap, bufferKeys: string[] | null = null) {
+    //     this.ensureSpace(items.length, bufferManagersMap);
+    //     const { offsetMap } = this;
+    //     // For block insert (truly new, consecutive offsets)
+    //     const blockItems: any[] = [];
+    //     let blockStart: number | null = null;
+    //     let lastBlockOffset: number | null = null;
+    //     // For single insert (existing or tombstone-assigned)
+    //     const singleItems: any[] = [];
+    //     const singleOffsets: number[] = [];
+    //     for (const item of items) {
+    //         let offset = offsetMap.get(item.key);
+    //         if (offset !== undefined) {
+    //             // Already present, update in place
+    //             singleItems.push(item);
+    //             singleOffsets.push(offset);
+    //         } else {
+    //             // Assign offset (tombstone or new)
+    //             if (this.tombstoneOffsets.length > 0) {
+    //                 offset = this.tombstoneOffsets.pop() as number;
+    //                 offsetMap.set(item.key, offset);
+    //                 singleItems.push(item);
+    //                 singleOffsets.push(offset);
+    //             } else {
+    //                 offset = this._length++;
+    //                 if (offset >= this._capacity) throw new Error("The Size Should Be Increased!!");
+    //                 offsetMap.set(item.key, offset);
+    //                 // Check for consecutive block
+    //                 if (blockStart === null) {
+    //                     blockStart = offset;
+    //                     lastBlockOffset = offset;
+    //                     blockItems.push(item);
+    //                 } else if (lastBlockOffset !== null && offset === lastBlockOffset + 1) {
+    //                     lastBlockOffset = offset;
+    //                     blockItems.push(item);
+    //                 } else {
+    //                     // Not consecutive, flush current block
+    //                     if (blockItems.length > 0) {
+    //                         this._insertBlock(blockItems, blockStart, bufferManagersMap, bufferKeys);
+    //                         blockItems.length = 0;
+    //                     }
+    //                     blockStart = offset;
+    //                     lastBlockOffset = offset;
+    //                     blockItems.push(item);
+    //                 }
+    //             }
+    //         }
+    //     }
+    //     // Flush any remaining block
+    //     if (blockItems.length > 0 && blockStart !== null) {
+    //         this._insertBlock(blockItems, blockStart, bufferManagersMap, bufferKeys);
+    //     }
+    //     // Insert singles
+    //     if (singleItems.length > 0) {
+    //         if (bufferKeys) {
+    //             for (const key of bufferKeys) {
+    //                 const bufferManagerComp = bufferManagersMap.get(key);
+    //                 if (!bufferManagerComp) throw new Error("insertBulk bufferKey does not exist");
+    //                 const { bufferManager, adaptor } = bufferManagerComp;
+    //                 bufferManager.insertBulk(singleItems.map(adaptor), singleOffsets);
+    //             }
+    //         } else {
+    //             for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+    //                 bufferManager.insertBulk(singleItems.map(adaptor), singleOffsets);
+    //             }
+    //         }
+    //     }
+    // }
+    // // Helper for block insert
+    // private _insertBlock(blockItems: any[], blockStart: number, bufferManagersMap: BufferManagersMap, bufferKeys: string[] | null) {
+    //     if (bufferKeys) {
+    //         for (const key of bufferKeys) {
+    //             const bufferManagerComp = bufferManagersMap.get(key);
+    //             if (!bufferManagerComp) throw new Error("insertBulk bufferKey does not exist");
+    //             const { bufferManager, adaptor } = bufferManagerComp;
+    //             bufferManager.insertBlock(blockItems, blockStart, adaptor, Float32Array);
+    //         }
+    //     } else {
+    //         for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+    //             bufferManager.insertBlock(blockItems, blockStart, adaptor, Float32Array);
+    //         }
+    //     }
+    // }
+    // ...existing code...
+    // want to add stack load to this method
+    // if offsetMap.has(item.key) === false get next offset, add the item to stack
+    // create a single big float32array and fill it with the items
+    // bufferManager.insertBulk([bigFloat32Array], [offsets[0]])
     insertBulk(items, bufferManagersMap, bufferKeys = null) {
         this.ensureSpace(items.length, bufferManagersMap);
         const { offsetMap } = this;
+        let offsetStart = null;
         const offsets = [];
+        const blockLoad = [];
         for (const item of items) {
             let o = offsetMap.get(item.key);
-            const offset = o !== undefined ? o : this.nextOffset();
-            offsetMap.set(item.key, offset);
-            offsets.push(offset);
+            if (o === undefined && this.tombstoneOffsets.length > 0) {
+                // If there is a tombstone, use it
+                o = this.tombstoneOffsets.pop();
+                offsetMap.set(item.key, o);
+            }
+            if (o !== undefined) {
+                // Already exist or there is a random empty space in earlear part of memory.
+                // insert for single slots 
+                if (bufferKeys) {
+                    for (const key of bufferKeys) {
+                        const bufferManagerComp = bufferManagersMap.get(key);
+                        if (bufferManagerComp === undefined)
+                            throw new Error("insertBulk bufferKey does not exist");
+                        const { bufferManager, adaptor } = bufferManagerComp;
+                        bufferManager.insertBulk([adaptor(item)], [o]);
+                    }
+                }
+                else {
+                    for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+                        bufferManager.insertBulk([adaptor(item)], [o]);
+                    }
+                }
+            }
+            else {
+                // offset comes from increment function
+                // this part stacks data to be load a a single big block.
+                const offset = this.nextOffset();
+                if (offset === undefined) {
+                    throw new Error("The Size Should Be Increased!!");
+                }
+                offsets.push(offset);
+                offsetMap.set(item.key, offset);
+                blockLoad.push(item);
+                if (offsetStart === null) {
+                    offsetStart = offset;
+                }
+            }
+        }
+        if (offsetStart === null)
+            return;
+        for (let i = 0; i < offsets.length - 1; i++) {
+            if (offsets[i] - offsets[i + 1] !== -1) {
+                // TODO: DELETE THIS
+                throw new Error("consecutive is not consecutive");
+            }
         }
         if (bufferKeys) {
             for (const key of bufferKeys) {
@@ -35,12 +169,12 @@ export class BufferOrchestrator {
                 if (bufferManagerComp === undefined)
                     throw new Error("insertBulk bufferKey does not exist");
                 const { bufferManager, adaptor } = bufferManagerComp;
-                bufferManager.insertBulk(items.map(adaptor), offsets);
+                bufferManager.insertBlock(blockLoad, offsetStart, adaptor, Float32Array);
             }
         }
         else {
             for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
-                bufferManager.insertBulk(items.map(adaptor), offsets);
+                bufferManager.insertBlock(blockLoad, offsetStart, adaptor, Float32Array);
             }
         }
     }
@@ -54,7 +188,7 @@ export class BufferOrchestrator {
                 offsets.push(offset);
             }
             else {
-                throw new Error("updateBulk item Key does not exist");
+                throw new Error(`updateBulk item Key does not exist, cannot update: ${item.key}`);
             }
         }
         if (bufferKeys) {
@@ -89,15 +223,18 @@ export class BufferOrchestrator {
     getOffset(key) {
         return this.offsetMap.get(key);
     }
-    nextOffset() {
+    nextTombstone() {
         if (this.tombstoneOffsets.length > 0) {
             const offset = this.tombstoneOffsets.pop();
             return offset;
         }
+        return undefined;
+    }
+    nextOffset() {
         if (this._length < this._capacity) {
             return this._length++;
         }
-        return false;
+        return undefined;
     }
     ensureSpace(itemsLength, bufferManagersMap) {
         if (itemsLength <= this.emptySpace)

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

@@ -0,0 +1,159 @@
+"use strict";
+// import { BufferOrchestrator as BufferOrchestratorI, BufferManagersMap, BufferManager } from "./types";
+// const EXTRA_SIZE = 10;
+// export class BufferOrchestrator implements BufferOrchestratorI {
+//     _capacity: number;
+//     offsetMap: Map<string, number>;
+//     tombstoneOffsets: number[];
+//     _length: number;
+//     constructor({ capacity = 10 } = {}) {
+//         this._capacity = capacity;
+//         this.offsetMap = new Map();
+//         this.tombstoneOffsets = [];
+//         this._length = 0;
+//     }
+//     resetWithCapacity(bufferManagersMap: BufferManagersMap, capacity: number | null = null) {
+//         this._capacity = capacity !== null ? capacity : this._capacity;
+//         for (const [key, { bufferManager }] of bufferManagersMap) {
+//             bufferManager.resetWithCapacity(this._capacity);
+//         }
+//         this.offsetMap.clear();
+//         this.tombstoneOffsets = [];
+//         this._length = 0;
+//     }
+//     insertBulk(items: any[], bufferManagersMap: BufferManagersMap, bufferKeys: string[] | null = null) {
+//         this.ensureSpace(items.length, bufferManagersMap);
+//         const { offsetMap } = this;
+//         const offsets = [];
+//         for (const item of items) {
+//             let o = offsetMap.get(item.key);
+//             const offset = o !== undefined ? o : this.nextOffset() as number;
+//             if (offset === undefined) {
+//                 throw new Error("The Size Should Be Increased!!")
+//             }
+//             offsetMap.set(item.key, offset);
+//             offsets.push(offset);
+//         }
+//         if (bufferKeys) {
+//             for (const key of bufferKeys) {
+//                 const bufferManagerComp = bufferManagersMap.get(key);
+//                 if (bufferManagerComp === undefined) throw new Error("insertBulk bufferKey does not exist");
+//                 const { bufferManager, adaptor } = bufferManagerComp;
+//                 bufferManager.insertBulk(items.map(adaptor), offsets);
+//             }
+//         } else {
+//             for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+//                 bufferManager.insertBulk(items.map(adaptor), offsets);
+//             }
+//         }
+//     }
+//     // does not assign offset to the new items.
+//     updateBulk(items: any[], bufferManagersMap: BufferManagersMap, bufferKeys: string[] | null = null) {
+//         const { offsetMap } = this;
+//         const offsets = [];
+//         for (const item of items) {
+//             const offset = offsetMap.get(item.key);
+//             if (offset !== undefined) {
+//                 offsets.push(offset);
+//             } else {
+//                 throw new Error("updateBulk item Key does not exist");
+//             }
+//         }
+//         if (bufferKeys) {
+//             for (const key of bufferKeys) {
+//                 const bufferManagerComp = bufferManagersMap.get(key);
+//                 if (bufferManagerComp === undefined) throw new Error("updateBulk bufferKey does not exist");
+//                 const { bufferManager, adaptor } = bufferManagerComp;
+//                 bufferManager.insertBulk(items.map(adaptor), offsets);
+//             }
+//         } else {
+//             for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+//                 bufferManager.insertBulk(items.map(adaptor), offsets);
+//             }
+//         }
+//     }
+//     deleteBulk(keys: string[], bufferManagersMap: BufferManagersMap) {
+//         const offsets = [];
+//         for (const key of keys) {
+//             const offset = this.getOffset(key);
+//             if (offset !== undefined) {
+//                 offsets.push(offset);
+//                 this.offsetMap.delete(key);
+//                 this.tombstoneOffsets.push(offset);
+//             }
+//         }
+//         for (const [key, { bufferManager }] of bufferManagersMap) {
+//             bufferManager.deleteBulk(offsets);
+//         }
+//     }
+//     getOffset(key: string) {
+//         return this.offsetMap.get(key);
+//     }
+//     nextOffset(): number | undefined {
+//         if (this.tombstoneOffsets.length > 0) {
+//             const offset = this.tombstoneOffsets.pop() as number;
+//             return offset;
+//         }
+//         if (this._length < this._capacity) {
+//             return this._length++;
+//         }
+//         return undefined;
+//     }
+//     ensureSpace(itemsLength: number, bufferManagersMap: BufferManagersMap) {
+//         if (itemsLength <= this.emptySpace) return;
+//         const newCapacity = this.length + itemsLength;
+//         for (const [key, { bufferManager }] of bufferManagersMap) {
+//             bufferManager.extendBuffer(this.length, newCapacity);
+//         }
+//         this._capacity = newCapacity;
+//     }
+//     defrag(bufferManagers: BufferManagersMap, bufferKeys: string[]) { // TODO defrag and leave some empty space
+//         const offsetMap = this.offsetMap;
+//         const newCapacity = offsetMap.size + EXTRA_SIZE;
+//         if (bufferKeys) {
+//             for (const key of bufferKeys) {
+//                 const offset = offsetMap.get(key);
+//                 if (offset !== undefined) {
+//                     for (const [key, { bufferManager }] of bufferManagers) {
+//                         bufferManager.defrag([offset], this.length, newCapacity);
+//                     }
+//                 }
+//             }
+//         } else {
+//             for (const [key, { bufferManager }] of bufferManagers) {
+//                 bufferManager.defrag(offsetMap.values(), this.length, newCapacity);
+//             }
+//         }
+//         this._defrag();
+//         this._length = offsetMap.size;
+//         this._capacity = newCapacity;
+//         this.tombstoneOffsets = [];
+//     }
+//     /**
+//      * Flushes metadata and sets length to 0 without actualize change on buffers
+//      * This method created for cases in which data is loaded on each frame
+//      */
+//     flush({ capacity = 10 } = {}) {
+//         this._length = 0;
+//         this._capacity = capacity;
+//         this.tombstoneOffsets = []
+//         this.offsetMap.clear();
+//     }
+//     _defrag() {
+//         const newOffsetMap = new Map();
+//         let newOffset = 0;
+//         for (const [key, offset] of this.offsetMap) {
+//             newOffsetMap.set(key, newOffset++);
+//         }
+//         this.offsetMap = newOffsetMap
+//     }
+//     get length() {
+//         return this._length;
+//     }
+//     get emptySpace() {
+//         return this._capacity - this.offsetMap.size;
+//     }
+//     get capacity() {
+//         return this._capacity;
+//     }
+// }

package/util/account/single-attribute-buffer-management/object-store.js

@@ -23,6 +23,13 @@ export class ObjectStore {
             }
         }
     }
+    insertBlock(objects, startOffset) {
+        for (let i = 0; i < objects.length; i++) {
+            const object = objects[i];
+            const offset = startOffset + i;
+            this._container[offset] = object;
+        }
+    }
     defrag(offsetValues, occupiedCapacity, newCapacity) {
         const hold = this._createEmptyList(newCapacity);
         for (let i = 0; i < offsetValues.length; i++) {

package/util/build-strategy/static-dynamic.js

@@ -9,21 +9,31 @@ export class StaticDynamicStrategy {
     _staticDynamicState = StaticDynamicState.DYNAMIC;
     _transitionLevel = 8; // Default transition level
     _lastStaticDynamicState = StaticDynamicState.STATIC;
-    constructor(globe, transitionLevel = 8) {
+    _lastGeometry = null;
+    _toStatic;
+    constructor(globe, transitionLevel = 8, toStatic) {
         this.globe = globe;
         this._transitionLevel = transitionLevel;
+        this._toStatic = toStatic;
         this.updateState();
     }
     updateState() {
         const currentLOD = this.globe.api_GetCurrentLODWithDecimal();
         const state = currentLOD < this._transitionLevel ? StaticDynamicState.STATIC : StaticDynamicState.DYNAMIC;
+        const currentGeometry = this.globe.api_GetCurrentGeometry();
         if (this._lastStaticDynamicState === StaticDynamicState.DYNAMIC && state === StaticDynamicState.STATIC) {
             this._staticDynamicState = StaticDynamicState.TO_STATIC;
+            this._toStatic();
+        }
+        else if ((currentGeometry !== this._lastGeometry) && state === StaticDynamicState.STATIC) {
+            this._staticDynamicState = StaticDynamicState.TO_STATIC;
+            this._toStatic();
         }
         else {
             this._staticDynamicState = state;
         }
         this._lastStaticDynamicState = this._staticDynamicState;
+        this._lastGeometry = currentGeometry;
     }
     getState() {
         return this._staticDynamicState;

package/util/check/typecheck.js

@@ -9,6 +9,18 @@ const doesOwnProperties = (properties, errorMessage) => {
 };
 export const isHexColor = (hexColor) => /^#[0-9A-F]{6}$/i.test(hexColor);
 export const isHexColorWithOpacity = (hexColor) => /^#[0-9A-F]{6}[0-9a-f]{0,2}$/i.test(hexColor);
+export const colorCheck = (color) => {
+    if (Array.isArray(color)) {
+        if (color.length !== 4)
+            throw new TypeError("Color must be an array 4 numbers RGBA");
+        color.forEach(c => {
+            if (typeof c !== "number")
+                throw new TypeError("Color array must contain only numbers");
+            if (c < 0 || c > 1)
+                throw new RangeError("Color values must be between 0 and 1");
+        });
+    }
+};
 export const opacityCheck = (opacity) => {
     if (typeof opacity !== "number")
         throw new TypeError("style.opacity must a number");

package/util/frame-counter-trigger.js

@@ -0,0 +1,84 @@
+import { CameraUniformBlockTotemCache } from "../programs/totems/camerauniformblock";
+export class FrameCounterTrigger {
+    globe;
+    count = 0;
+    threshold;
+    timeoutMs;
+    timeoutId = null;
+    accumulatedChanges = {
+        geometry: false,
+        look: false,
+        lod: false,
+        lod2DWheel: false,
+        elevationScale: false,
+        screenMoved: false
+    };
+    cameraBlockTotem;
+    updateCallback;
+    constructor(globe, threshold, timeoutMs, updateCallback) {
+        this.threshold = threshold;
+        this.timeoutMs = timeoutMs;
+        this.updateCallback = updateCallback;
+        this.globe = globe;
+        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+    }
+    trigger(level = null) {
+        const globeChanges = this.cameraBlockTotem.getGlobeChanges();
+        if (!globeChanges.screenMoved)
+            return;
+        this.setChanges(globeChanges);
+        if (globeChanges.geometry || globeChanges.elevationScale || globeChanges.lod2DWheel) {
+            this.triggerUpdate();
+            return;
+        }
+        this.count++;
+        if (this.count === 1) {
+            this.startTimeout();
+        }
+        if (this.count >= this.threshold) {
+            this.triggerUpdate();
+        }
+    }
+    startTimeout() {
+        this.clearTimeout();
+        this.timeoutId = setTimeout(() => {
+            this.triggerUpdate();
+        }, this.timeoutMs);
+    }
+    triggerUpdate() {
+        this.clearTimeout();
+        this.updateCallback(this.accumulatedChanges);
+        this.reset();
+    }
+    clearTimeout() {
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+    }
+    setChanges(changes) {
+        // accumulate true states until reset
+        this.accumulatedChanges.geometry = this.accumulatedChanges.geometry || changes.geometry;
+        this.accumulatedChanges.look = this.accumulatedChanges.look || changes.look;
+        this.accumulatedChanges.lod = this.accumulatedChanges.lod || changes.lod;
+        this.accumulatedChanges.elevationScale = this.accumulatedChanges.elevationScale || changes.elevationScale;
+        this.accumulatedChanges.screenMoved = this.accumulatedChanges.screenMoved || changes.screenMoved;
+        this.accumulatedChanges.lod2DWheel = this.accumulatedChanges.lod2DWheel || changes.lod2DWheel;
+    }
+    getLevel() {
+        return this.accumulatedChanges;
+    }
+    reset() {
+        this.count = 0;
+        this.accumulatedChanges.geometry = false;
+        this.accumulatedChanges.look = false;
+        this.accumulatedChanges.lod = false;
+        this.accumulatedChanges.lod2DWheel = false;
+        this.accumulatedChanges.elevationScale = false;
+        this.accumulatedChanges.screenMoved = false;
+        this.clearTimeout();
+    }
+    free() {
+        CameraUniformBlockTotemCache.release(this.globe);
+    }
+}

package/util/geometry/index.js

@@ -40,7 +40,8 @@ function normalize(array, newLength = 1) {
     }
     return result;
 }
+// TODO carry the usefull content to math module. 
 function sphereCoord(long, lat, globe, height = 0) {
-    return normalize(globe.api_GetCartesian3DPoint(long, lat, 0, 0), 6378.137 + height);
+    return normalize(globe.api_GetCartesian3DPoint(long, lat, 0, false), 6378.137 + height);
 }
 export { createBBoxMatrix, latLongToPixelXY, latLongBboxtoPixelXYBbox, sphereCoord, normalize };

package/util/webglobjectbuilders.js

@@ -211,8 +211,8 @@ export function decodeBase64(data) {
  * @returns An HTMLImageElement with the image data loaded.
  */
 export function createImageFromBase64(encodedData) {
-    const bytes = decodeBase64(encodedData);
-    const blob = new Blob([bytes], { type: "image/png" });
+    const source = decodeBase64(encodedData).buffer;
+    const blob = new Blob([source], { type: "image/png" });
     const urlCreator = window.URL || window.webkitURL;
     const imageUrl = urlCreator.createObjectURL(blob);
     const image = new Image();

package/write-text/context-text4.js

@@ -0,0 +1,140 @@
+// @ts-ignore
+import { CSZMode } from "@pirireis/webglobe";
+import { isTextFont, opacityCheck } from "../util/check/typecheck";
+/**
+ * TODOs:
+ * 1) update all if initials change (propably need a context and a callback to iterate over zPayload)
+ * 2) expose a mechanic to update text on zoom change
+ * 3) extend the mechanic on 2 to other events
+ *
+ * TODO: key check and raise error if doesnt exist
+ */
+const defaultStyle = {
+    textFont: {
+        name: 'Arial',
+        textColor: '#FFFFFF', // beyaz
+        hollowColor: '#000000', // siyah
+        size: 12, // piksel
+        hollow: true,
+        bold: true,
+        italic: false,
+    },
+    opacity: 1.0,
+    zMode: CSZMode.Z_GROUND_PERVERTEX,
+};
+// xOffset = 0,
+// yOffset = 0,
+// doDraw = true,
+// textAdaptor = null,
+// coordinatesAdaptor = null,
+// keyAdaptor = null,
+// opacityAdaptor = null,
+// angleAdaptor = null,
+// angleOnSphere = false,
+// positionAdaptor = (item: any, i: number, container: any[], properties?: any): string => "left",
+export class ContextTextWriter4 {
+    globe;
+    itemMap;
+    style;
+    doDraw;
+    textAdaptor;
+    deleteAdaptor;
+    zoomLevelAdaptor;
+    xOffset;
+    yOffset;
+    angleOptions;
+    constructor(globe, textAdaptor, deleteAdaptor, zoomLevelAdaptor = (zoomLevel) => (item) => {
+        return {
+            opacityMultiplier: 1,
+            sizeMultiplier: 1
+        };
+    }, style = defaultStyle, angleOptions = {
+        angleOnSphere: false,
+        angleIsOn: false
+    }, doDraw = true, offset = { x: 0, y: 0 }) {
+        this.globe = globe;
+        this.itemMap = new Map();
+        this.setStyle(style);
+        this.angleOptions = angleOptions;
+        this.doDraw = doDraw;
+        this.style = style;
+        this.angleOptions = angleOptions;
+        this.textAdaptor = textAdaptor;
+        this.deleteAdaptor = deleteAdaptor;
+        this.zoomLevelAdaptor = zoomLevelAdaptor;
+        this.xOffset = offset.x;
+        this.yOffset = offset.y;
+    }
+    setDoDraw(bool) {
+        this.doDraw = bool;
+        this.globe.DrawRender();
+    }
+    setStyle(style) {
+        isTextFont(style.textFont);
+        opacityCheck(style.opacity); //TODO: use shallow copy
+        this.style = style;
+        this.globe.DrawRender();
+    }
+    setOpacity(opacity) {
+        this.style.opacity = opacity;
+        this.globe.DrawRender();
+    }
+    draw() {
+        if (!this.doDraw)
+            return;
+        const { globe, style, itemMap, xOffset, yOffset } = this;
+        const { textFont, opacity: opacity_ } = style;
+        const textSize = textFont.size;
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        const angleIsOn = is3D ? (this.angleOptions.angleIsOn && this.angleOptions.angleOnSphere) : (this.angleOptions.angleIsOn);
+        const zoomLevel = globe.api_GetCurrentLODWithDecimal();
+        const zoomAdaptor = this.zoomLevelAdaptor(zoomLevel);
+        for (const item of itemMap.values()) {
+            const { lat, long, text, opacity = null, angle = null, zPayload, position } = item;
+            const { x, y } = globe.api_GetScreenPointFromGeo({
+                long: long,
+                lat: lat,
+                z: 0,
+            }, style.zMode === CSZMode.Z_MSL);
+            const { opacityMultiplier, sizeMultiplier } = zoomAdaptor(zPayload);
+            const o = (opacity === null ? opacity_ : opacity * opacity_) * opacityMultiplier;
+            textFont.size = sizeMultiplier * textSize;
+            textFont.position = position;
+            if (x !== null && y !== null)
+                globe.api_DrawContextTextMultiLine(text, textFont, o, { x: x + xOffset, y: y - yOffset }, angleIsOn, angle);
+        }
+        textFont.size = textSize;
+    }
+    insertText(data) {
+        const textDatas = this.textAdaptor(data);
+        for (const textData of textDatas) {
+            this.itemMap.set(textData.key, textData);
+        }
+    }
+    insertTextBulk(datas) {
+        for (const data of datas) {
+            this.insertText(data);
+        }
+    }
+    deleteText(data) {
+        const key = this.deleteAdaptor ? this.deleteAdaptor(data) : data;
+        if (this.itemMap.has(key)) {
+            this.itemMap.delete(key);
+        }
+    }
+    deleteTextBulk(datas) {
+        for (const data of datas) {
+            this.deleteText(data);
+        }
+    }
+    setOffsets(x, y) {
+        this.xOffset = x;
+        this.yOffset = y;
+    }
+    clear() {
+        this.itemMap.clear();
+    }
+    free() {
+        this.itemMap = null;
+    }
+}