@pirireis/webglobeplugins 0.15.34 → 0.16.0

package/dist/circle-line-chain/plugin.js

@@ -0,0 +1,411 @@
+import { LineOnGlobeCache } from '../programs/line-on-globe/naive-accurate-flexible';
+import { CircleCache, EDGE_COUNT as flatCircleEdgeCount, centerCoords2dflatDataCreator } from '../programs/line-on-globe/circle-accurate-flat';
+import { CircleCache as Circle3DCache } from '../programs/line-on-globe/circle-accurate-3d';
+import { BufferOrchestrator, BufferManager } from "../util/account";
+import { ChainListMap } from "../range-tools-on-terrain/circle-line-chain/chain-list-map";
+import { keyMethod } from "./util";
+import { populateFloat32Array } from "../util/jshelpers/data-filler";
+import { ContextTextWriter3 } from '../write-text/context-text3';
+import { opacityCheck, mapGetOrThrow } from '../util/check/typecheck';
+import { createBufferAndReadInfo } from '../util/gl-util/buffer/attribute-loader';
+import { sphereCoord } from '../util/geometry/index';
+/**
+ * Insert info to chain list map (nodes and properties)
+ *
+ * ask chain list map for text data
+ * ask chain list map for buffer data
+ *
+ *
+ * addNode
+ * insertBulk
+ * deleteChain
+ * deleteNodes
+ * updateCoordinates()
+ * updateChainProperties
+ */
+/**
+ *
+ *
+ * @typedef chain
+ * @property {string} chainKey
+ * @property {StyleProperties} chainProperties
+ *
+ * @typedef {Object} Node
+ * @property {string} key
+ * @property {number} long
+ * @property {number} lat
+ * @property {number} altitude
+ * @property {StyleProperties} circleProperties
+ *
+ * @typedef {Object} Node
+ * @property {string} key
+ * @property {number} long
+ * @property {number} lat
+ *
+ * @typedef StyleProperties
+ * @property {Array<number>} rgba 0-1
+ * @property { number} dashOpacity 0-1
+ * @property { number} dashRatio 0-1
+ * @property { number } circleDashAngle 0-360
+ * @property { number} altitude
+ *
+ * //property {Array<Node>} nodes
+ */
+const textWriterGetOrThrow = mapGetOrThrow("textWriterIDs is invalid");
+export class CircleLineChainPlugin {
+    /**
+     *
+     * @param {*} id
+     * @param {Map<key, ContextTextWriter3>} textWritersMap //import { ContextTextWriter3 } from "@pirireis/webglobeplugins/write-text/context-text3";
+     */
+    constructor(id, { drawCircleOn = true, textWritersMap = new Map(), textDataPreAdaptor = null, circleFlatEdgeCount = flatCircleEdgeCount - 2 } = {}) {
+        this.id = id;
+        this._checktextWritersMap(textWritersMap);
+        this._textWritersMap = textWritersMap;
+        this._textWritersMap.forEach((writer) => writer.setKeyAdaptor((v, i, c, properties) => v.__identity__));
+        this._opacity = 1;
+        this._chainListMap = new ChainListMap(keyMethod);
+        this.bufferOrchestrator = new BufferOrchestrator({ capacity: 10 });
+        this._drawCircleOn = drawCircleOn;
+        this._textDataPreAdaptor = textDataPreAdaptor;
+        this._circleFlatEdgeCount = circleFlatEdgeCount + 2;
+    }
+    // init
+    // API
+    setDrawCircleOn(bool) {
+        if (typeof bool !== 'boolean')
+            throw new Error("setDrawCircleOn parameter must be a boolean");
+        this._drawCircleOn = bool;
+        this.globe.DrawRender();
+    }
+    // ---- updateBulk
+    /**
+     * @param {Array<chain>} data
+     * @typedef chain
+     * @property {string} chainKey
+     * @property {Array<Node>} nodes
+
+     */
+    updateCoordinatesBulk(data, { textWriterIDs = [] } = {}) {
+        // update implicit data structure
+        // find keys to update.. (inserted data and the radius of "from")
+        // updateBuffers
+        // update text
+        const chainKeys = [];
+        for (const chain of data) {
+            chainKeys.push(chain.chainKey);
+            chain.nodes.forEach((node) => {
+                this._chainListMap.updateCoordsinatesOfNode(node, chain.chainKey);
+            });
+        }
+        this._reconstructChains(chainKeys);
+        this._updateTexts(chainKeys, textWriterIDs);
+    }
+    /**
+     * @param {*} chainKey
+     * @param {Array<{nodeKey, circleProperties:Map[propertyName ,value],  lineProperties:Map[propertyName ,value] }} propertyMap
+     */
+    updateNodesProperties(chainKey, nodesAndPropertyMap, { textWriterIDs = [] } = {}) {
+        this._chainListMap.updateNodesProperties(chainKey, nodesAndPropertyMap);
+        this._reconstructChains([chainKey]);
+        this._updateTexts([chainKey], textWriterIDs);
+        this.globe.DrawRender();
+    }
+    /**
+     * @param {*} chainKey
+     * @param {Map<propertyName ,value} propertyMap
+     */
+    updateChainProperties(chainKey, propertyMap, { textWriterIDs = [] } = {}) {
+        this._chainListMap.updateChainProperties(chainKey, propertyMap);
+        this._reconstructChains([chainKey]);
+        if (textWriterIDs)
+            this._updateTexts([chainKey], textWriterIDs);
+    }
+    updateNodeCoordinates(node, chainKey, { textWriterIDs = [] } = {}) {
+        this._chainListMap.updateCoordsinatesOfNode(node, chainKey);
+        if (textWriterIDs)
+            this._updateTexts([chainKey], textWriterIDs);
+        this._reconstructChains([chainKey]);
+        this.globe.DrawRender();
+    }
+    /**
+     *
+     * @param {Array<string>} textWriterIDs | textWritersMap keys to be used for writing text.
+     * @param {Array<string>} chainKeys | if empty, all texts will be updated
+     */
+    updateText(textWriterIDs = [], chainKeys = null) {
+        if (chainKeys === null)
+            chainKeys = this._chainListMap.getAllChainKeysIterator();
+        this._updateTexts(chainKeys, textWriterIDs);
+        this.globe.DrawRender();
+    }
+    // ---- insertBulk
+    /**
+     *
+     * @param {Array<chain>} data
+     */
+    insertBulk(data, { textWriterIDs = [] } = {}) {
+        // first insert everything to implicit structure,
+        // then iterate over data again to update text
+        // let _reconstractChainBufferData method interact with data and bufferOrchestrator.
+        const chainKeysToConstruct = [];
+        for (const { chainKey, chainProperties, nodes } of data) {
+            this._chainListMap.setChain(chainKey, nodes);
+            this._chainListMap.setChainProperties(chainKey, chainProperties);
+            chainKeysToConstruct.push(chainKey);
+        }
+        this._reconstructChains(chainKeysToConstruct);
+        if (textWriterIDs)
+            this._updateTexts(chainKeysToConstruct, textWriterIDs);
+        this.globe.DrawRender();
+    }
+    /**
+     * @param {Node} node
+     * @param {*} chainKey
+     * @param {*} theNodeKeyFront | node key of the next node, null places to the last
+     */
+    addNode(node, chainKey, { theNodeKeyFront = null, textWriterIDs = [] } = {}) {
+        this._chainListMap.addNode(node, chainKey, theNodeKeyFront);
+        if (textWriterIDs)
+            this._updateTexts([chainKey], textWriterIDs);
+        this._reconstructChains([chainKey]);
+        this.globe.DrawRender();
+    }
+    setOpacity(opacity) {
+        opacityCheck(opacity);
+        this._textWritersMap.forEach((writer) => writer.setOpacity(opacity));
+        this._opacity = opacity;
+        this.globe.DrawRender();
+    }
+    getChain(chainKey) {
+        this._chainListMap.getNodes(chainKey);
+    }
+    /**
+     *
+     * @param {*} chainKeys
+     */
+    deleteChains(chainKeys) {
+        const bufferKeys = [];
+        for (const chainKey of chainKeys) {
+            bufferKeys.push(...this._chainListMap.deleteChainAndReturnChainKeys(chainKey));
+        }
+        this._textWritersMap.forEach((writer) => writer.deleteTextBulk(bufferKeys));
+        this._updateTexts(chainKeys, this._textWritersMap.keys());
+        this.bufferOrchestrator.deleteBulk(bufferKeys, this.bufferManagersCompMap);
+        this.globe.DrawRender();
+    }
+    /**
+     *
+     * @param {Array<{chainKey, nodeKeys:[]} keysAndNodes
+     */
+    deleteNodes(keysAndNodes, { textWriterIDs = [] } = {}) {
+        const bufferKeys = [];
+        const chainKeysToReconstuct = [];
+        keysAndNodes.forEach(({ chainKey, nodeKeys }) => {
+            bufferKeys.push(...this._chainListMap.deleteNodesBelongToAChain(chainKey, nodeKeys));
+            chainKeysToReconstuct.push(chainKey);
+        });
+        this._textWritersMap.forEach((writer) => writer.deleteTextBulk(bufferKeys));
+        this.bufferOrchestrator.deleteBulk(bufferKeys, this.bufferManagersCompMap);
+        this._reconstructChains(chainKeysToReconstuct);
+        this._updateTexts(chainKeysToReconstuct, textWriterIDs);
+        this.globe.DrawRender();
+    }
+    init(globe, gl) {
+        this.gl = gl;
+        this.globe = globe;
+        this._initOrchestrations();
+    }
+    // implicit
+    _checktextWritersMap(textWritersMap) {
+        if (!(textWritersMap instanceof Map))
+            throw new Error("textWritersMap is not an instance of Map");
+        textWritersMap.forEach((v) => {
+            if (!(v instanceof ContextTextWriter3))
+                throw new Error("textWritersMap element is not an instance of ContextTextWriter3");
+        });
+    }
+    _initOrchestrations() {
+        const { gl, globe } = this;
+        this.lineProgram = LineOnGlobeCache.get(globe);
+        this.circleProgram2d = CircleCache.get(globe);
+        this.circle3DProgram = Circle3DCache.get(globe);
+        const _circleFlatEdgeCount = this._circleFlatEdgeCount;
+        {
+            // createBuffers
+            const bufferType = "DYNAMIC_DRAW";
+            const initialCapacity = this.bufferOrchestrator.capacity;
+            this.bufferManagersCompMap = new Map([
+                ["centerCoords2d", {
+                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(globe.api_GetMercator2DPoint(item.long, item.lat)),
+                    }],
+                ["centerCoords3d", {
+                        'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
+                        'adaptor': (item) => sphereCoord(item.long, item.lat, globe, item.altitude),
+                    }],
+                ["targetCoords2d", {
+                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(globe.api_GetMercator2DPoint(item.targetLong, item.targetLat)),
+                    }],
+                ["targetCoords3d", {
+                        'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
+                        'adaptor': (item) => sphereCoord(item.targetLong, item.targetLat, globe, item.altitude),
+                    }],
+                ["rgba", {
+                        'bufferManager': new BufferManager(gl, 4, { bufferType, initialCapacity }),
+                        'adaptor': (item) => {
+                            if (item.lineProperties?.rgba)
+                                return new Float32Array(item.lineProperties.rgba);
+                            return new Float32Array(item.chainProperties.rgba);
+                        }
+                    }],
+                // ["bigRadius", {
+                //     'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                //     'adaptor': (item) => new Float32Array([item.bigRadius])
+                // }],
+                ["dashRatio", {
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.chainProperties.dashRatio])
+                    }],
+                ["dashOpacity", {
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.chainProperties.dashOpacity])
+                    }],
+                ["circleDashAngle", {
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => {
+                            if (item.circleProperties?.circleDashAngle)
+                                return new Float32Array([item.circleProperties.circleDashAngle / 360]);
+                            return new Float32Array([item.chainProperties.circleDashAngle / 360]);
+                        }
+                    }],
+                ["rgbaCircle", {
+                        "bufferManager": new BufferManager(gl, 4, { bufferType, initialCapacity }),
+                        "adaptor": (item) => {
+                            if (item.circleProperties?.rgba)
+                                return new Float32Array(item.circleProperties.rgba);
+                            return new Float32Array(item.chainProperties.rgba);
+                        }
+                    }],
+                // Mercator buffers
+                ["circleDashAngleMercator", {
+                        'bufferManager': new BufferManager(gl, 1 * _circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        'adaptor': (item) => {
+                            if (item.circleProperties?.circleDashAngle)
+                                return new Float32Array([item.circleProperties.circleDashAngle / 360]);
+                            return populateFloat32Array.fillFloat32Array(_circleFlatEdgeCount, item.chainProperties.circleDashAngle / 360);
+                        }
+                    }],
+                ["rgbaCircleMercator", {
+                        "bufferManager": new BufferManager(gl, 4 * _circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        "adaptor": (item) => {
+                            if (item.circleProperties?.rgba)
+                                return populateFloat32Array.fillWithListData(_circleFlatEdgeCount, item.circleProperties.rgba);
+                            return populateFloat32Array.fillWithListData(_circleFlatEdgeCount, item.chainProperties.rgba);
+                        }
+                    }],
+                ["dashOpacityMercator", {
+                        'bufferManager': new BufferManager(gl, 1 * _circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        'adaptor': (item) => populateFloat32Array.fillFloat32Array(_circleFlatEdgeCount, item.chainProperties.dashOpacity)
+                    }],
+                ["centerCoords2dMercator", {
+                        'bufferManager': new BufferManager(gl, 2 * _circleFlatEdgeCount, { bufferType, initialCapacity }),
+                        'adaptor': (item) => item.centerCoords2dflat,
+                    }],
+            ]);
+            const obj = (key) => createBufferAndReadInfo(this.bufferManagersCompMap.get(key).bufferManager.buffer);
+            this.lineVao = this.lineProgram.createVAO(...['centerCoords2d', 'centerCoords3d', 'targetCoords2d', 'targetCoords3d', 'dashRatio', 'dashOpacity', 'rgba'
+            ].map(key => obj(key)));
+            this.circleVao2d = this.circleProgram2d.createVAO(...["centerCoords2dMercator", "rgbaCircleMercator", "circleDashAngleMercator", "dashOpacityMercator"
+            ].map(key => obj(key)));
+            this.circle3DVao = this.circle3DProgram.createVAO(...["centerCoords3d", "targetCoords3d", "rgbaCircle", "circleDashAngle", "dashOpacity"
+            ].map(key => obj(key)));
+        }
+    }
+    _updateTexts(chainKeys, textWriterIDs) {
+        if (textWriterIDs.length === 0)
+            return;
+        const textWriters = textWriterGetOrThrow(this._textWritersMap, textWriterIDs);
+        chainKeys.forEach((chainKey) => {
+            this._chainListMap.textUpdate(chainKey, textWriters, this._textDataPreAdaptor);
+        });
+    }
+    _reconstructChains(chainKeys) {
+        const { globe } = this;
+        // const radiusM = radiusMethod(globe);
+        const callback = (v, i, array, chainProperties) => {
+            if (i === array.length - 1)
+                return null;
+            const centerCoords2dflat = centerCoords2dflatDataCreator(globe, v.long, v.lat, array[i + 1].long, array[i + 1].lat, { edgeCount: this._circleFlatEdgeCount });
+            const altitude = (v.altitude ?? chainProperties.altitude ?? 0) / 1000;
+            return {
+                chainProperties: chainProperties,
+                // bigRadius: radiusM(v, i, array),
+                targetLong: array[i + 1].long,
+                targetLat: array[i + 1].lat,
+                altitude: altitude,
+                long: v.long,
+                lat: v.lat,
+                lineProperties: v.lineProperties,
+                circleProperties: v.circleProperties,
+                centerCoords2dflat,
+                key: v.__identity__
+            };
+        };
+        const bulkData = [];
+        chainKeys.forEach((k) => {
+            this._chainListMap.calculateBufferPropertiesChain(k, callback, bulkData);
+        });
+        this._insertBulk(bulkData);
+    }
+    _insertBulk(bulkData) {
+        this.bufferOrchestrator.insertBulk(bulkData, this.bufferManagersCompMap);
+        this.globe.DrawRender();
+    }
+    // GLOBE API
+    free() {
+        if (this.isFreed)
+            return;
+        this.bufferManagersCompMap.forEach(({ bufferManager }) => {
+            bufferManager.free();
+        });
+        LineOnGlobeCache.release(this.globe);
+        CircleCache.release(this.globe);
+        Circle3DCache.release(this.globe);
+        // LineToTheOriginCache.release(this.globe);
+        this._textWritersMap.forEach((writer) => writer.free());
+        const { gl } = this;
+        gl.deleteVertexArray(this.lineVao);
+        gl.deleteVertexArray(this.circleVao2d);
+        gl.deleteVertexArray(this.circle3DVao);
+        this.lineProgram = null;
+        this.circleProgram2d = null;
+        this.isFreed = true;
+    }
+    draw3D() {
+        const { gl, globe } = this;
+        gl.disable(gl.DEPTH_TEST);
+        const drawOptions = {
+            drawRange: {
+                first: 0,
+                count: this.bufferOrchestrator.length
+            }
+        };
+        this.lineProgram.draw(this.lineVao, drawOptions, this._opacity);
+        this._textWritersMap.forEach((writer) => writer.draw());
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        if (this._drawCircleOn) {
+            if (is3D) {
+                this.circle3DProgram.draw(this.circle3DVao, this.bufferOrchestrator.length, this._opacity);
+            }
+            else {
+                this.circleProgram2d.draw(this.circleVao2d, this.bufferOrchestrator.length, this._circleFlatEdgeCount, this._opacity);
+            }
+        }
+        gl.enable(gl.DEPTH_TEST);
+    }
+}
+// const radiusMethod = (globe) => (v, i, array) => {
+//     return globe.Math.GetDist3D(v.long, v.lat, array[i + 1].long, array[i + 1].lat)
+// }

package/dist/circle-line-chain/util.js

@@ -0,0 +1 @@
+export const keyMethod = (chainKey, nodeKey) => `${chainKey}_${nodeKey}`;

package/dist/compass-rose/compass-rose-padding-flat.js

@@ -0,0 +1,230 @@
+import { PixelPaddingForFlatCompassCache } from "../programs/two-d/pixel-padding-for-compass";
+import { BufferManager, BufferOrchestrator } from "../util/account";
+import { PixelPaddingCompassTextWriter } from "./compass-text-writer";
+const PaddingAngle = 30;
+const textGapFit = 10;
+export class PixelPaddingCompassPlugin {
+    constructor(id, { opacity = 1, textAngleOn = true, defaultProperties = {
+        rgba: [1, 1, 1, 1],
+        pixelRadiusRatioBig: 0.8,
+        pixelRadiusRatioSmall: 0.6,
+    }, font = {
+        name: 'Arial',
+        textColor: '#FFFFFF',
+        hollowColor: '#000000',
+        size: 12, // piksel
+        hollow: true,
+        bold: true,
+        italic: false,
+    }, northFont = {
+        name: 'Arial',
+        textColor: '#BBAA00',
+        hollowColor: '#000000',
+        size: 14, // piksel
+        hollow: true,
+        bold: true,
+        italic: false,
+    } } = {}) {
+        this.id = id;
+        this.textAngleOn = textAngleOn;
+        this.defaultProperties = defaultProperties;
+        this.bufferOrchestrator = new BufferOrchestrator({ capacity: 10 });
+        this._font_hold = { font, northFont };
+        this.compassMap = new CompassMap(this);
+        this._opacity = opacity;
+        this.isFreed = false;
+    }
+    init(globe, gl) {
+        this.globe = globe;
+        this.resize();
+        this.gl = gl;
+        if (this.textAngleOn) {
+            this._createTextWriter();
+        }
+        this._initOrchestrations();
+    }
+    /**
+     * @param {string} key
+     * @param {number} long
+     * @param {number} lat
+     * @typedef properties
+     * @property {number} pixelRadiusRatioBig
+     * @property {number} pixelRadiusRatioSmall
+     * @property {[4 numbers between 0-1]} rgba
+     */
+    insert(key, long, lat, properties = null) {
+        this.__insertText(key, null, null, { properties, update: true });
+        this.compassMap.insert(key, long, lat, properties);
+        this.globe.DrawRender();
+    }
+    /**
+     *
+     * @param {string} key
+     */
+    delete(key) {
+        this.compassMap.delete(key);
+        this.globe.DrawRender();
+    }
+    setFont({ textFont = null, northFont = null } = {}) {
+        if (textFont)
+            this.writer.setFont(textFont);
+        if (northFont)
+            this.writer.setNorthFont(northFont);
+        this.globe.DrawRender();
+    }
+    setOpacity(opacity) {
+        this._opacity = opacity;
+        this.writer?.setOpacity(opacity);
+        this.globe.DrawRender();
+    }
+    getTextWriter() {
+        return this.writer;
+    }
+    _initOrchestrations() {
+        const { gl, globe } = this;
+        this.paddingProgram = PixelPaddingForFlatCompassCache.get(globe);
+        {
+            // createBuffers
+            const bufferType = "DYNAMIC_DRAW";
+            const initialCapacity = this.bufferOrchestrator.capacity;
+            this.bufferManagersCompMap = new Map([
+                ["screenCoordinates", {
+                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.x, item.y])
+                    }],
+                ["pixelRadiusRatioSmall", {
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.properties.pixelRadiusRatioSmall])
+                    }],
+                ["pixelRadiusRatioBig", {
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.properties.pixelRadiusRatioBig])
+                    }],
+                ["rgba", {
+                        'bufferManager': new BufferManager(gl, 4, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(item.properties.rgba)
+                    }],
+            ]);
+            const obj = function (bufferManagerComp) {
+                return { 'buffer': bufferManagerComp.bufferManager.buffer, 'stride': 0, 'offset': 0 };
+            };
+            this.paddingVao = this.paddingProgram.createVAO(...['screenCoordinates', 'pixelRadiusRatioSmall', 'pixelRadiusRatioBig', 'rgba'].map(key => obj(this.bufferManagersCompMap.get(key))));
+        }
+    }
+    _createTextWriter() {
+        this.writer = new PixelPaddingCompassTextWriter(this.globe, { angle: PaddingAngle, ...this._font_hold });
+    }
+    resize() {
+        this.writer?.resize();
+    }
+    __insertText(key, x, y, { properties, update = false } = {}) {
+        if (!this.writer)
+            return;
+        if (update) {
+            let radius;
+            if (properties != null && properties.pixelRadiusRatioBig) {
+                radius = properties.pixelRadiusRatioBig * this.radiusMultiplier;
+            }
+            else {
+                radius = this.defaultProperties.pixelRadiusRatioBig * this.radiusMultiplier;
+            }
+            this.writer.insertTextItem(key, x, y, radius + textGapFit);
+        }
+        else {
+            this.writer.insertTextItem(key, x, y);
+        }
+    }
+    // Globe API interface methods
+    draw2D() {
+        if (this.isFreed) {
+            console.warn("PixelPaddingCompassPlugin is freed, cannot draw.");
+            return;
+        }
+        ;
+        const { gl, globe, paddingProgram, paddingVao, bufferOrchestrator, bufferManagersCompMap } = this;
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        if (is3D)
+            return;
+        const items = this.compassMap.query(globe, this.writer);
+        if (items.length === 0)
+            return;
+        bufferOrchestrator.flush();
+        bufferOrchestrator.insertBulk(items, bufferManagersCompMap);
+        items.forEach((v) => {
+            this.__insertText(v.key, v.x, v.y);
+        });
+        gl.disable(gl.DEPTH_TEST);
+        paddingProgram.draw(paddingVao, bufferOrchestrator.length, this._opacity);
+        gl.enable(gl.DEPTH_TEST);
+        this.writer?.draw();
+    }
+    free() {
+        if (this.isFreed) {
+            console.warn("PixelPaddingCompassPlugin is already freed.");
+            return;
+        }
+        ;
+        this.isFreed = true;
+        this.compassMap.free();
+        const { globe, gl, paddingVao } = this;
+        gl.deleteVertexArray(paddingVao);
+        PixelPaddingForFlatCompassCache.release(globe);
+        this.bufferManagersCompMap.forEach(v => {
+            v.bufferManager.free();
+        });
+    }
+    resize() {
+        this.radiusMultiplier = this._shorterDimension() * 0.5;
+        this._reinsertAllText();
+    }
+    _reinsertAllText() {
+        this.compassMap.query(this.globe, this.writer).forEach((v) => {
+            this.__insertText(v.key, v.x, v.y, { properties: v.properties, update: true });
+        });
+    }
+    _shorterDimension() {
+        const globe = this.globe;
+        return Math.min(globe.api_ScrW(), globe.api_ScrH());
+    }
+}
+class CompassMap {
+    constructor(parent) {
+        this.coordsMemory = new Map();
+        this.propertyMemory = new Map();
+        this.parent = parent;
+    }
+    insert(key, long, lat, properties = null) {
+        this.coordsMemory.set(key, [long, lat]);
+        if (properties)
+            this.propertyMemory.set(key, properties);
+    }
+    delete(key) {
+        this.coordsMemory.delete(key);
+        this.propertyMemory.delete(key);
+    }
+    free() {
+        this.coordsMemory.clear();
+        this.propertyMemory.clear();
+        this.coordsMemory = null;
+        this.propertyMemory = null;
+    }
+    query(globe, writer) {
+        const { coordsMemory, propertyMemory } = this;
+        const defaultProperties = this.parent.defaultProperties;
+        const result = [];
+        coordsMemory.forEach((v, k, c) => {
+            const { x, y } = globe.api_GetScreenPointFromGeo({
+                long: v[0],
+                lat: v[1],
+                z: 0,
+            });
+            writer?.insertTextItem(k, x, y);
+            if (x !== null) {
+                const properties = { ...defaultProperties, ...propertyMemory.get(k) };
+                result.push({ key: k, x, y, properties });
+            }
+        });
+        return result;
+    }
+}
+function isOnTheScreen(globe, points) { }