@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/circle-line-chain/chain-list-map.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainListMap = void 0;
+/**
+ * set and get node data
+ * node indexes;
+ */
+var ChainListMap = /** @class */ (function () {
+    function ChainListMap(keyMethod) {
+        this._chainMap = new Map();
+        this._chainSideProperties = new Map();
+        this._indexMap = new Map(); // hold list index of lastly updated nodes. on add delete goes empty
+        this.keyMethod = keyMethod;
+    }
+    ChainListMap.prototype.getChain = function (chainKey) {
+        return this._chainMap.get(chainKey);
+    };
+    /**
+     *
+     * @param {*} node
+     * @param {*} chainKey
+     * @param {string|null} theNodeKeyFront
+     */
+    ChainListMap.prototype.addNode = function (node, chainKey, theNodeKeyFront) {
+        if (theNodeKeyFront === void 0) { theNodeKeyFront = null; }
+        var chain = this.getChain(chainKey);
+        var frontIndex = null;
+        for (var i = 0; i < chain.length; i++) {
+            var n_ode = chain[i];
+            if (n_ode.key === node.key) {
+                throw new Error("Chain node already exists");
+            }
+            if (n_ode.key === theNodeKeyFront) {
+                frontIndex = i;
+            }
+        }
+        if (theNodeKeyFront !== null) {
+            if (frontIndex !== null) {
+                chain.splice(frontIndex, 0, node);
+            }
+            else {
+                throw new Error("Could not find theNodeKeyFront");
+            }
+        }
+        else {
+            chain.push(node);
+        }
+        node.__identity__ = this.keyMethod(chainKey, node.key);
+        this._resetIndexChain(chainKey);
+    };
+    ChainListMap.prototype.deleteNodesBelongToAChain = function (chainKey, nodeKeys) {
+        var chain = this._chainMap.get(chainKey);
+        var deleteKeys = [];
+        var removeSet = new Set(nodeKeys);
+        var newChain = [];
+        for (var i = 0; i < chain.length - 1; i++) {
+            var node = chain[i];
+            var dKey = node.__identity__;
+            this._indexMap.delete(dKey);
+            if (removeSet.has(node.key)) {
+                deleteKeys.push(dKey);
+            }
+            else {
+                newChain.push(node);
+            }
+        }
+        { // last item case
+            var lastItem = chain[chain.length - 1];
+            this._indexMap.delete(lastItem.__identity__);
+            if (removeSet.has(lastItem.key)) {
+                if (chain.length > 1) {
+                    deleteKeys.push(chain[chain.length - 2].__identity__);
+                    deleteKeys.push(chain[chain.length - 1].__identity__);
+                }
+                ;
+            }
+            else {
+                newChain.push(lastItem);
+            }
+        }
+        this._chainMap.set(chainKey, newChain);
+        return deleteKeys;
+    };
+    ChainListMap.prototype.deleteChainAndReturnChainKeys = function (chainKey) {
+        var keys = this.getNodeKeysOfChain(chainKey);
+        this._chainMap.delete(chainKey);
+        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+            var key = keys_1[_i];
+            this._indexMap.delete(key);
+        }
+        return keys;
+    };
+    ChainListMap.prototype.updateNode = function (node, chainKey) {
+        var index = this.getIndexOfNode(chainKey, node.key);
+        var chain = this._chainMap.get(chainKey);
+        node.__identity__ = this.keyMethod(chainKey, node.key);
+        chain[index] = node;
+    };
+    ChainListMap.prototype.updateNodesProperties = function (chainKey, nodes) {
+        var _this = this;
+        nodes.forEach(function (node) {
+            var index = _this.getIndexOfNode(chainKey, node.key);
+            var chainNode = _this._chainMap.get(chainKey)[index];
+            if (node.circleProperties) {
+                if (typeof chainNode.circleProperties !== 'object')
+                    chainNode.circleProperties = {};
+                node.circleProperties.forEach(function (value, key, container) { return chainNode.circleProperties[key] = value; });
+            }
+            if (node.lineProperties) {
+                if (typeof chainNode.lineProperties !== 'object')
+                    chainNode.lineProperties = {};
+                node.lineProperties.forEach(function (value, key, container) { return chainNode.lineProperties[key] = value; });
+            }
+        });
+    };
+    ChainListMap.prototype.updateCoordsinatesOfNode = function (node, chainKey) {
+        var index = this.getIndexOfNode(chainKey, node.key);
+        var chain = this._chainMap.get(chainKey);
+        chain[index].long = node.long;
+        chain[index].lat = node.lat;
+    };
+    ChainListMap.prototype.setChain = function (chainKey, nodeList) {
+        var _this = this;
+        if (this._chainMap.has(chainKey))
+            this._flushIndexMap();
+        this._chainMap.set(chainKey, nodeList);
+        nodeList.forEach(function (v) { return v.__identity__ = _this.keyMethod(chainKey, v.key); });
+    };
+    ChainListMap.prototype.setChainProperties = function (chainKey, properties) {
+        this._chainSideProperties.set(chainKey, properties);
+    };
+    /**
+     *
+     * @param {string} chainKey
+     * @param {Map} properties
+     * // after this method update text and buffer data of the chain
+     */
+    ChainListMap.prototype.updateChainProperties = function (chainKey, properties) {
+        var memoryProperties = this._chainSideProperties.get(chainKey);
+        properties.forEach(function (value, key, m) {
+            memoryProperties[key] = value;
+        });
+    };
+    ChainListMap.prototype.getChainProperties = function (chainKey) {
+        this._chainSideProperties.get(chainKey);
+    };
+    /**
+     *
+     * @param {*} chainKey
+     * @param {*} callback | (value, index, array) => expexted output
+     */
+    ChainListMap.prototype.calculateBufferPropertiesChain = function (chainKey, callback, result) {
+        var chain = this._chainMap.get(chainKey);
+        var props = this._chainSideProperties.get(chainKey);
+        for (var i = 0; i < chain.length - 1; i++) {
+            var node = callback(chain[i], i, chain, props);
+            if (node !== null)
+                result.push(node);
+        }
+    };
+    /**
+     * @param {*} chainKey
+     * @param {*} textWriterObjs
+     * @param {*} nodeKeys use nodeKeys on updateCoordinatesOnly
+     */
+    ChainListMap.prototype.textUpdate = function (chainKey, textWriterObjs, dataPreAdaptor) {
+        var chain = this._chainMap.get(chainKey);
+        if (!chain)
+            return;
+        var data = (dataPreAdaptor) ? chain.map(dataPreAdaptor) : chain;
+        var properties = this._chainSideProperties.get(chainKey);
+        textWriterObjs.forEach(function (writer) {
+            writer.insertTextBulk(data, properties);
+        });
+    };
+    ChainListMap.prototype.getAllChainKeysIterator = function () {
+        return this._chainMap.keys();
+    };
+    ChainListMap.prototype.getIndexOfNode = function (chainKey, nodeKey) {
+        var key = this.keyMethod(chainKey, nodeKey);
+        if (this._indexMap.has(key))
+            return this._indexMap.get(key);
+        var chain = this._chainMap.get(chainKey);
+        for (var i = 0; i < chain.length; i++) {
+            var node = chain[i];
+            this._indexMap.set(key, i);
+            if (node.key === nodeKey) {
+                return i;
+            }
+        }
+    };
+    ChainListMap.prototype._flushIndexMap = function () {
+        this._indexMap.clear();
+    };
+    ChainListMap.prototype._resetIndexChain = function (chainKey) {
+        var chain = this._chainMap.get(chainKey);
+        for (var i = 0; i < chain.length; i++) {
+            var node = chain[i];
+            this._indexMap.set(this.keyMethod(chainKey, node.key), i);
+        }
+    };
+    ChainListMap.prototype.getNodeKeysOfChain = function (chainKey) {
+        var chain = this._chainMap.get(chainKey);
+        if (!chain)
+            return [];
+        var result = chain.map(function (v) { return v.__identity__; });
+        return result;
+    };
+    return ChainListMap;
+}());
+exports.ChainListMap = ChainListMap;

package/circle-line-chain/init.js

@@ -0,0 +1 @@
+"use strict";

package/circle-line-chain/plugin.js

@@ -0,0 +1,449 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircleLineChainPlugin = void 0;
+var naive_accurate_flexible_1 = require("../programs/line-on-globe/naive-accurate-flexible");
+var circle_accurate_flat_1 = require("../programs/line-on-globe/circle-accurate-flat");
+var circle_accurate_3d_1 = require("../programs/line-on-globe/circle-accurate-3d");
+var account_1 = require("../util/account");
+var chain_list_map_1 = require("./chain-list-map");
+var get_1 = require("../util/check/get");
+var util_1 = require("./util");
+var data_filler_1 = require("../util/jshelpers/data-filler");
+var context_text3_1 = require("../write-text/context-text3");
+var typecheck_1 = require("../util/check/typecheck");
+var attribute_loader_1 = require("../util/gl-util/buffer/attribute-loader");
+var index_1 = require("../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
+ */
+var textWriterGetOrThrow = (0, get_1.mapGetOrThrow)("textWriterIDs is invalid");
+var CircleLineChainPlugin = /** @class */ (function () {
+    /**
+     *
+     * @param {*} id
+     * @param {Map<[key, ContextTextWriter3]} textWritersMap //import { ContextTextWriter3 } from "@pirireis/webglobeplugins/write-text/context-text3";
+     */
+    function CircleLineChainPlugin(id, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.drawCircleOn, drawCircleOn = _c === void 0 ? true : _c, _d = _b.textWritersMap, textWritersMap = _d === void 0 ? new Map() : _d, _e = _b.textDataPreAdaptor, textDataPreAdaptor = _e === void 0 ? null : _e, _f = _b.circleFlatEdgeCount, circleFlatEdgeCount = _f === void 0 ? circle_accurate_flat_1.EDGE_COUNT - 2 : _f;
+        this.id = id;
+        this._checktextWritersMap(textWritersMap);
+        this._textWritersMap = textWritersMap;
+        this._textWritersMap.forEach(function (writer) { return writer.setKeyAdaptor(function (v, i, c, properties) { return v.__identity__; }); });
+        this._opacity = 1;
+        this._chainListMap = new chain_list_map_1.ChainListMap(util_1.keyMethod);
+        this.bufferOrchestrator = new account_1.BufferOrchestrator({ capacity: 10 });
+        this._drawCircleOn = drawCircleOn;
+        this._textDataPreAdaptor = textDataPreAdaptor;
+        this._circleFlatEdgeCount = circleFlatEdgeCount + 2;
+    }
+    // init
+    // API
+    CircleLineChainPlugin.prototype.setDrawCircleOn = function (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
+
+     */
+    CircleLineChainPlugin.prototype.updateCoordinatesBulk = function (data, _a) {
+        var _this = this;
+        var _b = _a === void 0 ? {} : _a, _c = _b.textWriterIDs, textWriterIDs = _c === void 0 ? [] : _c;
+        // update implicit data structure
+        // find keys to update.. (inserted data and the radius of "from")
+        // updateBuffers
+        // update text
+        var chainKeys = [];
+        var _loop_1 = function (chain) {
+            chainKeys.push(chain.chainKey);
+            chain.nodes.forEach(function (node) {
+                _this._chainListMap.updateCoordsinatesOfNode(node, chain.chainKey);
+            });
+        };
+        for (var _i = 0, data_1 = data; _i < data_1.length; _i++) {
+            var chain = data_1[_i];
+            _loop_1(chain);
+        }
+        this._reconstructChains(chainKeys);
+        this._updateTexts(chainKeys, textWriterIDs);
+    };
+    /**
+     * @param {*} chainKey
+     * @param {Array<{nodeKey, circleProperties:Map[propertyName ,value],  lineProperties:Map[propertyName ,value] }} propertyMap
+     */
+    CircleLineChainPlugin.prototype.updateNodesProperties = function (chainKey, nodesAndPropertyMap, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.textWriterIDs, textWriterIDs = _c === void 0 ? [] : _c;
+        this._chainListMap.updateNodesProperties(chainKey, nodesAndPropertyMap);
+        this._reconstructChains([chainKey]);
+        this._updateTexts([chainKey], textWriterIDs);
+        this.globe.DrawRender();
+    };
+    /**
+     * @param {*} chainKey
+     * @param {Map<propertyName ,value} propertyMap
+     */
+    CircleLineChainPlugin.prototype.updateChainProperties = function (chainKey, propertyMap, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.textWriterIDs, textWriterIDs = _c === void 0 ? [] : _c;
+        this._chainListMap.updateChainProperties(chainKey, propertyMap);
+        this._reconstructChains([chainKey]);
+        if (textWriterIDs)
+            this._updateTexts([chainKey], textWriterIDs);
+    };
+    CircleLineChainPlugin.prototype.updateNodeCoordinates = function (node, chainKey, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.textWriterIDs, textWriterIDs = _c === void 0 ? [] : _c;
+        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
+     */
+    CircleLineChainPlugin.prototype.updateText = function (textWriterIDs, chainKeys) {
+        if (textWriterIDs === void 0) { textWriterIDs = []; }
+        if (chainKeys === void 0) { chainKeys = null; }
+        if (chainKeys === null)
+            chainKeys = this._chainListMap.getAllChainKeysIterator();
+        this._updateTexts(chainKeys, textWriterIDs);
+        this.globe.DrawRender();
+    };
+    // ---- insertBulk
+    /**
+     *
+     * @param {Array<chain>} data
+     */
+    CircleLineChainPlugin.prototype.insertBulk = function (data, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.textWriterIDs, textWriterIDs = _c === void 0 ? [] : _c;
+        // first insert everything to implicit structure,
+        // then iterate over data again to update text
+        // let _reconstractChainBufferData method interact with data and bufferOrchestrator.
+        var chainKeysToConstruct = [];
+        for (var _i = 0, data_2 = data; _i < data_2.length; _i++) {
+            var _d = data_2[_i], chainKey = _d.chainKey, chainProperties = _d.chainProperties, nodes = _d.nodes;
+            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
+     */
+    CircleLineChainPlugin.prototype.addNode = function (node, chainKey, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.theNodeKeyFront, theNodeKeyFront = _c === void 0 ? null : _c, _d = _b.textWriterIDs, textWriterIDs = _d === void 0 ? [] : _d;
+        this._chainListMap.addNode(node, chainKey, theNodeKeyFront);
+        if (textWriterIDs)
+            this._updateTexts([chainKey], textWriterIDs);
+        this._reconstructChains([chainKey]);
+        this.globe.DrawRender();
+    };
+    CircleLineChainPlugin.prototype.setOpacity = function (opacity) {
+        (0, typecheck_1.opacityCheck)(opacity);
+        this._textWritersMap.forEach(function (writer) { return writer.setOpacity(opacity); });
+        this._opacity = opacity;
+        this.globe.DrawRender();
+    };
+    CircleLineChainPlugin.prototype.getChain = function (chainKey) {
+        this._chainListMap.getChain(chainKey);
+    };
+    /**
+     *
+     * @param {*} chainKeys
+     */
+    CircleLineChainPlugin.prototype.deleteChains = function (chainKeys) {
+        var bufferKeys = [];
+        for (var _i = 0, chainKeys_1 = chainKeys; _i < chainKeys_1.length; _i++) {
+            var chainKey = chainKeys_1[_i];
+            bufferKeys.push.apply(bufferKeys, this._chainListMap.deleteChainAndReturnChainKeys(chainKey));
+        }
+        this._textWritersMap.forEach(function (writer) { return writer.deleteTextBulk(bufferKeys); });
+        this._updateTexts(chainKeys, this._textWritersMap.keys());
+        this.bufferOrchestrator.deleteBulk(bufferKeys, this.bufferManagersCompMap);
+        this.globe.DrawRender();
+    };
+    /**
+     *
+     * @param {Array<{chainKey, nodeKeys:[]} keysAndNodes
+     */
+    CircleLineChainPlugin.prototype.deleteNodes = function (keysAndNodes, _a) {
+        var _this = this;
+        var _b = _a === void 0 ? {} : _a, _c = _b.textWriterIDs, textWriterIDs = _c === void 0 ? [] : _c;
+        var bufferKeys = [];
+        var chainKeysToReconstuct = [];
+        keysAndNodes.forEach(function (_a) {
+            var chainKey = _a.chainKey, nodeKeys = _a.nodeKeys;
+            bufferKeys.push.apply(bufferKeys, _this._chainListMap.deleteNodesBelongToAChain(chainKey, nodeKeys));
+            chainKeysToReconstuct.push(chainKey);
+        });
+        this._textWritersMap.forEach(function (writer) { return writer.deleteTextBulk(bufferKeys); });
+        this.bufferOrchestrator.deleteBulk(bufferKeys, this.bufferManagersCompMap);
+        this._reconstructChains(chainKeysToReconstuct);
+        this._updateTexts(chainKeysToReconstuct, textWriterIDs);
+        this.globe.DrawRender();
+    };
+    CircleLineChainPlugin.prototype.init = function (globe, gl) {
+        this.gl = gl;
+        this.globe = globe;
+        this._initOrchestrations();
+    };
+    // implicit
+    CircleLineChainPlugin.prototype._checktextWritersMap = function (textWritersMap) {
+        if (!(textWritersMap instanceof Map))
+            throw new Error("textWritersMap is not an instance of Map");
+        textWritersMap.forEach(function (v) {
+            if (!(v instanceof context_text3_1.ContextTextWriter3))
+                throw new Error("textWritersMap element is not an instance of ContextTextWriter3");
+        });
+    };
+    CircleLineChainPlugin.prototype._initOrchestrations = function () {
+        var _a, _b, _c;
+        var _this = this;
+        var _d = this, gl = _d.gl, globe = _d.globe;
+        this.lineProgram = naive_accurate_flexible_1.LineOnGlobeCache.get(globe);
+        this.circleProgram2d = circle_accurate_flat_1.CircleCache.get(globe);
+        this.circle3DProgram = circle_accurate_3d_1.CircleCache.get(globe);
+        var _circleFlatEdgeCount = this._circleFlatEdgeCount;
+        {
+            // createBuffers
+            var bufferType = "DYNAMIC_DRAW";
+            var initialCapacity = this.bufferOrchestrator.capacity;
+            this.bufferManagersCompMap = new Map([
+                ["centerCoords2d", {
+                        'bufferManager': new account_1.BufferManager(gl, 2, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        'adaptor': function (item) { return new Float32Array(globe.api_GetMercator2DPoint(item.long, item.lat)); },
+                    }],
+                ["centerCoords3d", {
+                        'bufferManager': new account_1.BufferManager(gl, 3, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        'adaptor': function (item) { return (0, index_1.sphereCoord)(item.long, item.lat, globe, item.altitude); },
+                    }],
+                ["targetCoords2d", {
+                        'bufferManager': new account_1.BufferManager(gl, 2, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        'adaptor': function (item) { return new Float32Array(globe.api_GetMercator2DPoint(item.targetLong, item.targetLat)); },
+                    }],
+                ["targetCoords3d", {
+                        'bufferManager': new account_1.BufferManager(gl, 3, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        'adaptor': function (item) { return (0, index_1.sphereCoord)(item.targetLong, item.targetLat, globe, item.altitude); },
+                    }],
+                ["rgba", {
+                        'bufferManager': new account_1.BufferManager(gl, 4, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        'adaptor': function (item) {
+                            var _a;
+                            if ((_a = item.lineProperties) === null || _a === void 0 ? void 0 : _a.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 account_1.BufferManager(gl, 1, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        'adaptor': function (item) { return new Float32Array([item.chainProperties.dashRatio]); }
+                    }],
+                ["dashOpacity", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        'adaptor': function (item) { return new Float32Array([item.chainProperties.dashOpacity]); }
+                    }],
+                ["circleDashAngle", {
+                        'bufferManager': new account_1.BufferManager(gl, 1, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        'adaptor': function (item) {
+                            var _a;
+                            if ((_a = item.circleProperties) === null || _a === void 0 ? void 0 : _a.circleDashAngle)
+                                return new Float32Array([item.circleProperties.circleDashAngle / 360]);
+                            return new Float32Array([item.chainProperties.circleDashAngle / 360]);
+                        }
+                    }],
+                ["rgbaCircle", {
+                        "bufferManager": new account_1.BufferManager(gl, 4, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        "adaptor": function (item) {
+                            var _a;
+                            if ((_a = item.circleProperties) === null || _a === void 0 ? void 0 : _a.rgba)
+                                return new Float32Array(item.circleProperties.rgba);
+                            return new Float32Array(item.chainProperties.rgba);
+                        }
+                    }],
+                // Mercator buffers
+                ["circleDashAngleMercator", {
+                        'bufferManager': new account_1.BufferManager(gl, 1 * _circleFlatEdgeCount, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        'adaptor': function (item) {
+                            var _a;
+                            if ((_a = item.circleProperties) === null || _a === void 0 ? void 0 : _a.circleDashAngle)
+                                return new Float32Array([item.circleProperties.circleDashAngle / 360]);
+                            return data_filler_1.populateFloat32Array.fillFloat32Array(_circleFlatEdgeCount, item.chainProperties.circleDashAngle / 360);
+                        }
+                    }],
+                ["rgbaCircleMercator", {
+                        "bufferManager": new account_1.BufferManager(gl, 4 * _circleFlatEdgeCount, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        "adaptor": function (item) {
+                            var _a;
+                            if ((_a = item.circleProperties) === null || _a === void 0 ? void 0 : _a.rgba)
+                                return data_filler_1.populateFloat32Array.fillWithListData(_circleFlatEdgeCount, item.circleProperties.rgba);
+                            return data_filler_1.populateFloat32Array.fillWithListData(_circleFlatEdgeCount, item.chainProperties.rgba);
+                        }
+                    }],
+                ["dashOpacityMercator", {
+                        'bufferManager': new account_1.BufferManager(gl, 1 * _circleFlatEdgeCount, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        'adaptor': function (item) { return data_filler_1.populateFloat32Array.fillFloat32Array(_circleFlatEdgeCount, item.chainProperties.dashOpacity); }
+                    }],
+                ["centerCoords2dMercator", {
+                        'bufferManager': new account_1.BufferManager(gl, 2 * _circleFlatEdgeCount, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                        'adaptor': function (item) { return item.centerCoords2dflat; },
+                    }],
+            ]);
+            var obj_1 = function (key) { return (0, attribute_loader_1.createBufferAndReadInfo)(_this.bufferManagersCompMap.get(key).bufferManager.buffer); };
+            this.lineVao = (_a = this.lineProgram).createVAO.apply(_a, ['centerCoords2d', 'centerCoords3d', 'targetCoords2d', 'targetCoords3d', 'dashRatio', 'dashOpacity', 'rgba'
+            ].map(function (key) { return obj_1(key); }));
+            this.circleVao2d = (_b = this.circleProgram2d).createVAO.apply(_b, ["centerCoords2dMercator", "rgbaCircleMercator", "circleDashAngleMercator", "dashOpacityMercator"
+            ].map(function (key) { return obj_1(key); }));
+            this.circle3DVao = (_c = this.circle3DProgram).createVAO.apply(_c, ["centerCoords3d", "targetCoords3d", "rgbaCircle", "circleDashAngle", "dashOpacity"
+            ].map(function (key) { return obj_1(key); }));
+        }
+    };
+    CircleLineChainPlugin.prototype._updateTexts = function (chainKeys, textWriterIDs) {
+        var _this = this;
+        if (textWriterIDs.length === 0)
+            return;
+        var textWriters = textWriterGetOrThrow(this._textWritersMap, textWriterIDs);
+        chainKeys.forEach(function (chainKey) {
+            _this._chainListMap.textUpdate(chainKey, textWriters, _this._textDataPreAdaptor);
+        });
+    };
+    CircleLineChainPlugin.prototype._reconstructChains = function (chainKeys) {
+        var _this = this;
+        var globe = this.globe;
+        // const radiusM = radiusMethod(globe);
+        var callback = function (v, i, array, chainProperties) {
+            var _a, _b;
+            if (i === array.length - 1)
+                return null;
+            var centerCoords2dflat = (0, circle_accurate_flat_1.centerCoords2dflatDataCreator)(globe, v.long, v.lat, array[i + 1].long, array[i + 1].lat, { edgeCount: _this._circleFlatEdgeCount });
+            var altitude = ((_b = (_a = v.altitude) !== null && _a !== void 0 ? _a : chainProperties.altitude) !== null && _b !== void 0 ? _b : 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: centerCoords2dflat,
+                key: v.__identity__
+            };
+        };
+        var bulkData = [];
+        chainKeys.forEach(function (k) {
+            _this._chainListMap.calculateBufferPropertiesChain(k, callback, bulkData);
+        });
+        this._insertBulk(bulkData);
+    };
+    CircleLineChainPlugin.prototype._insertBulk = function (bulkData) {
+        this.bufferOrchestrator.insertBulk(bulkData, this.bufferManagersCompMap);
+        this.globe.DrawRender();
+    };
+    // GLOBE API
+    CircleLineChainPlugin.prototype.free = function () {
+        if (this.isFreed)
+            return;
+        this.bufferManagersCompMap.forEach(function (_a) {
+            var bufferManager = _a.bufferManager;
+            bufferManager.free();
+        });
+        naive_accurate_flexible_1.LineOnGlobeCache.release(this.globe);
+        circle_accurate_flat_1.CircleCache.release(this.globe);
+        circle_accurate_3d_1.CircleCache.release(this.globe);
+        // LineToTheOriginCache.release(this.globe);
+        this._textWritersMap.forEach(function (writer) { return writer.free(); });
+        var gl = this.gl;
+        gl.deleteVertexArray(this.lineVao);
+        gl.deleteVertexArray(this.circleVao2d);
+        gl.deleteVertexArray(this.circle3DVao);
+        this.lineProgram = null;
+        this.circleProgram2d = null;
+        this.isFreed = true;
+    };
+    CircleLineChainPlugin.prototype.draw3D = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe;
+        gl.disable(gl.DEPTH_TEST);
+        var drawOptions = {
+            drawRange: {
+                first: 0,
+                count: this.bufferOrchestrator.length
+            }
+        };
+        this.lineProgram.draw(this.lineVao, drawOptions, this._opacity);
+        this._textWritersMap.forEach(function (writer) { return writer.draw(); });
+        var 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);
+    };
+    return CircleLineChainPlugin;
+}());
+exports.CircleLineChainPlugin = CircleLineChainPlugin;
+// const radiusMethod = (globe) => (v, i, array) => {
+//     return globe.Math.GetDist3D(v.long, v.lat, array[i + 1].long, array[i + 1].lat)
+// }

package/circle-line-chain/util.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyMethod = void 0;
+var keyMethod = function (chainKey, nodeKey) { return "".concat(chainKey, "_").concat(nodeKey); };
+exports.keyMethod = keyMethod;