@pirireis/webglobeplugins 0.6.26-a → 0.6.28-a

package/circle-line-chain/plugin_old.js

@@ -1,398 +0,0 @@
-import { LineOnGlobeCache } from '../programs/line-on-globe/naive';
-import { CircleCache } from '../programs/line-on-globe/circle';
-import { LineToTheOriginCache } from "../programs/line-on-globe/to-the-origin"
-import { BufferOrchestrator, BufferManager } from "../util/account";
-import { ChainListMap } from "./chain-list-map";
-import { mapGetOrThrow } from "../util/check/get";
-import { keyMethod } from "./util";
-import { ContextTextWriter3 } from '../write-text/context-text3';
-// TODO: Add update buffer and update text mehods on add, delete, update methods
-
-
-/**
- * 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 StyleProperties
- * @property {[0-1,0-1,0-1,0-1]} rgba
- * @property { 0-1 } dashOpacity 
- * @property { 0-1 } dashRatio
- * @property {0-360} circleDashAngle 
- * @property {Array<node>} nodes
- */
-
-const radian = Math.PI / 180;
-
-export class CircleLineChainPlugin {
-    /**
-     * 
-     * @param {*} id 
-     * @param {Map<[key, ContextTextWriter3]} textContextWriterInjectionMap //import { ContextTextWriter3 } from "@pirireis/webglobeplugins/write-text/context-text3"; 
-     */
-    constructor(id, {
-        drawCircleOn = true,
-        textContextWriterInjectionMap = new Map(),
-        textDataPreAdaptor = null
-    } = {}) {
-        this.id = id;
-        this._checkTextContextWriterInjectionMap(textContextWriterInjectionMap);
-        this._textContextWriterInjectionMap = textContextWriterInjectionMap;
-        this._textContextWriterInjectionMap.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;
-    }
-
-    // init
-
-    init(globe, gl) {
-        this.gl = gl;
-        this.globe = globe
-        this._initOrchestrations()
-    }
-
-    _checkTextContextWriterInjectionMap(textContextWriterInjectionMap) {
-        if (!(textContextWriterInjectionMap instanceof Map)) throw new Error("textContextWriterInjectionMap is not an instance of Map");
-        textContextWriterInjectionMap.forEach((v) => {
-            if (!(v instanceof ContextTextWriter3)) throw new Error("textContextWriterInjectionMap element is not an instance of ContextTextWriter3");
-        });
-    }
-
-    _initOrchestrations() {
-        const { gl, globe } = this;
-        this.lineProgram = LineOnGlobeCache.get(globe);
-        this.circleProgram = CircleCache.get(globe);
-        this.lineToTheOriginProgram = LineToTheOriginCache.get(globe);
-        {
-            // createBuffers
-            const bufferType = "DYNAMIC_DRAW";
-            const initialCapacity = this.bufferOrchestrator.capacity;
-            this.bufferManagersCompMap = new Map(
-                [
-                    ["centerCoords", {
-                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([radian * item.long, radian * item.lat]),
-                    }],
-                    ["targetCoords", {
-                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([radian * item.targetLong, radian * item.targetLat])
-                    }],
-                    ["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);
-                        }
-                    }]
-                ]
-            );
-            // (startPotisionBufferObj, endPositionBufferObj, dashRatioBufferObj, colorBufferObj)
-            const obj = function (bufferManagerComp) {
-                return { 'buffer': bufferManagerComp.bufferManager.buffer, 'stride': 0, 'offset': 0 }
-            };
-            this.lineVao = this.lineProgram.createVAO(
-                ...['centerCoords', 'targetCoords', 'dashRatio', 'dashOpacity', 'rgba'].map(key => obj(this.bufferManagersCompMap.get(key))));
-            this.circleVao = this.circleProgram.createVAO(
-                ...["centerCoords", "bigRadius", "rgbaCircle", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key))));
-            this.toOriginVao = this.lineToTheOriginProgram.createVAO(
-                ...["targetCoords", "rgba"].map(key => obj(this.bufferManagersCompMap.get(key))));
-        }
-
-    }
-
-
-    // API
-    setDrawCircleOn(bool) {
-        if (typeof bool !== 'boolean') throw new Error("setDrawCircleOn parameter must be a boolean");
-        this._drawCircleOn = bool;
-        this.globe.DrawRender();
-    }
-    // -- update bulk family
-    /**
-     * 
-     * @param {Array<chain>} data 
-     * @typedef chain
-     * @property {string} chainKey
-     * @property {Array<node>} nodes
-     * @typedef {Object} node
-     * @property {string} key
-     * @property {number} long
-     * @property {number} lat  
-     */
-    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);
-    }
-
-    // ---- insertBulk family
-    /**
-     * 
-     * @param {Array<chain>} data 
-     * @typedef chain
-     * @property {string} chainKey
-     * @property {StyleProperties} chainProperties
-
-     *  } chainProperties
-     * 
-     * @typedef {Object} node
-     * @property {string} key
-     * @property {number} long
-     * @property {number} lat  
-     * @property {StyleProperties} circleProperties
-     */
-    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 {{key, long, lat}} node
-     * @param {*} chainKey 
-     * @param {*} theNodeKeyFront | node key of the next node, null places to the last
-     */
-    addNode(node, chainKey, { theNodeKeyFront = null, textWriterIDs = [] } = {}) {
-        // TODO: if before object is null update the last two elements of the chain only. 
-        this._chainListMap.addNode(node, chainKey, theNodeKeyFront);
-        if (textWriterIDs) this._updateTexts([chainKey], textWriterIDs);
-        this._reconstructChains([chainKey]);
-        this.globe.DrawRender();
-
-    }
-
-
-
-    updateNodeCoordinates(node, chainKey, { textWriterIDs = [] } = {}) {
-        this._chainListMap.updateCoordsinatesOfNode(node, chainKey);
-        if (textWriterIDs) this._updateTexts([chainKey], textWriterIDs);
-        this._reconstructChains([chainKey]);
-        this.globe.DrawRender();
-    }
-
-
-
-    setOpacity(opacity) {
-        if (typeof opacity !== 'number') throw new Error("opacity must be a number");
-        if (opacity < 0 || 1 < opacity) throw new Error("opacity must be between 0-1");
-        this._textContextWriterInjectionMap.forEach((writer) => writer.setOpacity(opacity));
-        this._opacity = opacity;
-        this.globe.DrawRender();
-    }
-
-
-
-    getChain(chainKey) {
-        this._chainListMap.getChain(chainKey);
-    }
-
-    /**
-     * 
-     * @param {*} chainKeys 
-     */
-    deleteChains(chainKeys) {
-        const bufferKeys = [];
-        for (const chainKey of chainKeys) {
-            bufferKeys.push(...this._chainListMap.deleteChainAndReturnChainKeys(chainKey));
-        }
-        this._textContextWriterInjectionMap.forEach((writer) => writer.deleteTextBulk(bufferKeys));
-        this._updateTexts(chainKeys, this._textContextWriterInjectionMap.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._textContextWriterInjectionMap.forEach((writer) => writer.deleteTextBulk(bufferKeys));
-        this.bufferOrchestrator.deleteBulk(bufferKeys, this.bufferManagersCompMap);
-        this._reconstructChains(chainKeysToReconstuct);
-        this._updateTexts(chainKeysToReconstuct, textWriterIDs);
-        this.globe.DrawRender();
-
-    }
-
-
-    updateText(textWriterIDs) {
-        const chainKeyIterator = this._chainListMap.getAllChainKeysIterator();
-        this._updateTexts(chainKeyIterator, textWriterIDs);
-    }
-
-
-    // implicit
-
-    _updateTexts(chainKeys, textWriterIDs) {
-        if (textWriterIDs.length === 0) return;
-        const textWriters = textWriterGetOrThrow(this._textContextWriterInjectionMap, textWriterIDs)
-        chainKeys.forEach((chainKey) => {
-            this._chainListMap.textUpdate(chainKey, textWriters, this._textDataPreAdaptor);
-        })
-    }
-
-
-    _reconstructChains(chainKeys) {
-        const { globe } = this;
-        //     this.lineVao = this.lineProgram.createVAO(
-        //         ...['centerCoords', 'targetCoords', 'dashRatio', 'dashOpacity', 'rgba'].map(key => obj(this.bufferManagersCompMap.get(key))));
-        //     this.circleVao = this.circleProgram.createVAO(
-        //         ...["centerCoords", "bigRadius", "rgba", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key))));
-        // }   
-
-        const radiusM = radiusMethod(globe);
-        const callback = (v, i, array, chainProperties) => {
-            if (i == array.length - 1) return null;
-            return {
-                chainProperties: chainProperties,
-                bigRadius: radiusM(v, i, array),
-                targetLong: array[i + 1].long,
-                targetLat: array[i + 1].lat,
-                long: v.long,
-                lat: v.lat,
-                lineProperties: v.lineProperties,
-                circleProperties: v.circleProperties,
-                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
-    //TODO:
-    free() {
-        if (this.isFreed) return;
-        this.bufferManagersCompMap.forEach(({ bufferManager }) => {
-            bufferManager.free();
-        })
-        LineOnGlobeCache.release(this.globe);
-        CircleCache.release(this.globe);
-        this.lineProgram = null;
-        this.circleProgram = null;
-        this.isFreed = true;
-    }
-
-    draw3D() {
-        const { gl, globe } = this;
-        gl.disable(gl.DEPTH_TEST);
-        this.lineProgram.draw(this.lineVao, this.bufferOrchestrator.length, this._opacity);
-        if (this._drawCircleOn) this.circleProgram.draw(this.circleVao, this.bufferOrchestrator.length, this._opacity);
-        this._textContextWriterInjectionMap.forEach((writer) => writer.draw());
-        gl.enable(gl.DEPTH_TEST);
-        this.lineToTheOriginProgram.draw(this.toOriginVao, this.bufferOrchestrator.length, this._opacity);
-    }
-}
-
-
-
-const radiusMethod = (globe) => (v, i, array) => {
-    return globe.Math.GetDist3D(v.long, v.lat, array[i + 1].long, array[i + 1].lat)
-}
-
-const textWriterGetOrThrow = mapGetOrThrow("textWriterIds is invalid")

package/rangerings/rangerings copy.js

@@ -1,219 +0,0 @@
-import { rings } from "../programs";
-import { COMPASS_MODES } from "./enum";
-import { PaddingFreeAngleCache } from "../programs/rings/distancering";
-
-import RangeRingAngleText from "./rangeringangletext";
-const { circleProgramCache, PaddingProgramCache, CirclePaddySharedBuffer } = rings;
-
-/**
- * @typedef RangeRingData
- * @property {number} centerX
- * @property {number} centerY
- * @property {Array<Ring>} rings
- * 
- * @typedef Ring
- * @property {number} radius
- * @property {number} padding
- * @property {[number, number, number]} color
- * 
- */
-
-
-
-export default class {
-
-    constructor(id, { oneDegreePadding = true, compass = COMPASS_MODES.REAL, showNumbers = true, numbersStyle = null, opacity = 1 } = {}) {
-        this.id = id;
-        this.compass = compass;
-        this._showNumbers = showNumbers;
-        this._numbersStyle = numbersStyle;
-        this._opacity = opacity;
-        this.circleEdgeCount = 360;
-        this._onedegreepaddingOn = oneDegreePadding;
-        this.bufferManager = null;
-
-        this._deleteCounter = 0;
-        this._deleteThreshold = 10;
-    }
-
-
-    setOneDegreePaddingOn(oneDegreePadding) {
-        this._onedegreepaddingOn = oneDegreePadding;
-        this.globe.DrawRender();
-    }
-
-    init(globe, gl) {
-        this.gl = gl;
-        this.globe = globe;
-        this.circleFlatProgram = circleProgramCache.getProgram(globe);
-        this.paddyFlatProgram = PaddingProgramCache.getProgram(globe);
-        this.paddingFreeAngleProgram = PaddingFreeAngleCache.getProgram(globe);
-        if (this._showNumbers) {
-            this.textPlugin = new RangeRingAngleText(globe, this.id + "text", { flatCompassMode: this.compass, style: this._numbersStyle, opacity: this._opacity });
-            delete this._numbersStyle;
-        }
-    }
-
-    // TODO: Add text free
-    free() {
-
-        this.circleProgramCache?.releaseProgram(this.globe);
-        this.PaddingProgramCache?.releaseProgram(this.globe);
-        this.PaddingFreeAngleCache?.releaseProgram(this.globe);
-        this.gl.deleteVertexArray(this.bufferManager?.vao);
-        this.gl.deleteVertexArray(this.paddingBufferManager?.vao);
-        this.paddingBufferManager?.free();
-        this.bufferManager?.free();
-        this.textPlugin?.free();
-        this.circleFlatProgram = null;
-        this.paddyFlatProgram = null;
-        this.bufferManager = null;
-        this.paddingBufferManager = null;
-        this.textPlugin = null;
-    }
-
-
-    setOpacity(opacity) {
-        this._opacity = opacity;
-        this.textPlugin?.setOpacity(opacity); // TODO impolement this
-        this.globe.DrawRender();
-    }
-
-    setGeometry() {
-        this.textPlugin?.setGeometry();
-    }
-
-
-    draw3D() {
-        const { circleFlatProgram, paddyFlatProgram, paddingFreeAngleProgram, bufferManager, compass, gl, circleEdgeCount, paddingBufferManager, _opacity } = this;
-        if (this.bufferManager !== null && bufferManager.length > 0) {
-            gl.disable(gl.DEPTH_TEST);
-            circleFlatProgram.draw(bufferManager, compass, circleEdgeCount, _opacity);
-            if (this._onedegreepaddingOn) paddyFlatProgram.draw(bufferManager, 360, compass, _opacity);
-            paddingFreeAngleProgram.draw(paddingBufferManager, compass, _opacity);
-            gl.enable(gl.DEPTH_TEST);
-        }
-    }
-
-
-
-    /**
-     * @param {RangeRingData} rangeRingData
-     * 0 compass limps
-     * other real distance limp
-     */
-    setCampass(compass) {
-        this.compass = compass;
-        this.textPlugin?.setCompass(compass);
-        this.globe.DrawRender();
-    }
-
-    initilizeBufferManager(initialRingCapacity, bufferDrawType) {
-        const { gl, globe } = this
-        this.bufferDrawType = bufferDrawType;
-        this.bufferManager = new CirclePaddySharedBuffer(gl, globe, { bufferType: bufferDrawType, initialRingCapacity: initialRingCapacity });
-        this.paddingBufferManager = this.paddingFreeAngleProgram.createBuffer({ bufferType: bufferDrawType, initialRingCapacity });
-    }
-
-
-    /**
-     * @typedef {Array<{ringID, radius, paddingRange}>} rings
-     * @param {Array<centerID:string, x:number, y:number, stepAngle:number, rgba:[4 numbers], rings:rings} items
-     */
-    insertBulk(items) {
-        const insertData = ringItemsToCircleBufferInsertDataAdaptor(items);
-
-        this.bufferManager.insertBulk(insertData);
-        for (const item of items) {
-            item.paddingAngles = angleToPaddingAngles(item.stepAngle, 0);
-        }
-        this.paddingBufferManager.insertBulk(items);
-        this.textPlugin?.insertBulk(items);
-        this.globe.DrawRender();
-    }
-
-
-    /**
-     * 
-     * @param {Array<{centerID, x, y}>} items 
-     */
-    updateCentersXY(items) {
-        this.bufferManager.updateCentersXY(items);
-        this.paddingBufferManager.updateCentersXY(items);
-        this.textPlugin?.updateCentersXY(items);
-        this.globe.DrawRender();
-    }
-
-
-    /**
-     * @param   {Array<{centerID, rgba:[4 numbers]}>} centerColors
-     */
-    updateCentersColor(centerColors) {
-        this.bufferManager.updateCentersColor(centerColors);
-        this.paddingBufferManager.updateCentersColor(centerColors);
-        this.globe.DrawRender();
-    }
-
-
-    /**
-     * @param {Array<{centerID}>} centerIds
-     */
-    removeCenters(centerIds) {
-        this.bufferManager.removeCenters(centerIds);
-        this.paddingBufferManager.removeCenters(centerIds);
-        this.textPlugin?.removeCenters(centerIds);
-        this._deleteCounter += centerIds.length;
-        if (this._deleteCounter > this._deleteThreshold) {
-            // this is naive since we are not checking the actual deletion
-            // but it works
-            this._deleteCounter = 0;
-            this.bufferManager.defrag();
-            this.paddingBufferManager.defrag();
-        }
-        this.globe.DrawRender();
-
-    }
-
-    /**
-     * 
-     * @param {Array<{centerID, hide, textHide}>} centerHides
-     */
-    updateCentersHide(centerHides) {
-        this.bufferManager.updateCentersHide(centerHides);
-        this.paddingBufferManager.updateCentersHide(centerHides);
-        this.textPlugin?.updateCentersHide(centerHides);
-        this.globe.DrawRender();
-    }
-}
-
-
-
-
-const ringItemsToCircleBufferInsertDataAdaptor = (ringItems) => {
-
-    const result = [];
-    for (const { centerID, x, y, rgba, rings, hide = 0, textHide = 0 } of ringItems) {
-        const resultRings = [];
-        for (const { ringID, radius, padding } of rings) {
-            resultRings.push({
-                ringID,
-                radius,
-                padding: padding / 5,
-                rgba,
-            });
-        }
-
-        result.push({
-            centerID,
-            x,
-            y,
-            rings: resultRings,
-            hide,
-            textHide
-        });
-    }
-    return result;
-};
-
-const angleToPaddingAngles = (gapDegree, offsetDegree = 0) => Array.from({ length: Math.ceil(360 / gapDegree) }, (_, i) => (i * gapDegree + offsetDegree) * Math.PI / 180);
-