@pirireis/webglobeplugins 0.5.2 → 0.5.3-a

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

@@ -80,6 +80,16 @@ export class ChainListMap {
     }
 
 
+    updateCoordsinatesOfNode(node, chainKey) {
+
+        const index = this.getIndexOfNode(chainKey, node.key)
+        const chain = this._chainMap.get(chainKey);
+        node.__identity__ = this.keyMethod(chainKey, node.key);
+        chain[index].long = node.long;
+        chain[index].long = node.lat;
+
+    }
+
     setChain(chainKey, nodeList) {
         if (this._chainMap.has(chainKey)) this._flushIndexMap();
         this._chainMap.set(chainKey, nodeList);
@@ -116,11 +126,10 @@ export class ChainListMap {
      * @param {*} chainKey 
      * @param {*} callback | (value, index, array) => expexted output
      */
-    calculateBufferPropertiesChain(chainKey, callback, result, nodeIndexes = null) {
+    calculateBufferPropertiesChain(chainKey, callback, result,) {
         const chain = this._chainMap.get(chainKey);
         const props = this._chainSideProperties.get(chainKey);
-        const iterator = nodeIndexes !== null ? nodeIndexes : chain.keys();
-        for (const i of iterator) {
+        for (let i = 0; i < chain.length - 1; i++) {
             const node = callback(chain[i], i, chain, props);
             if (node !== null) result.push(node);
         }
@@ -132,21 +141,12 @@ export class ChainListMap {
      * @param {*} textWriterObjs 
      * @param {*} nodeKeys use nodeKeys on updateCoordinatesOnly
      */
-    textUpdate(chainKey, textWriterObjs, nodeIndexes = null) {
+    textUpdate(chainKey, textWriterObjs) {
         const chain = this._chainMap.get(chainKey);
         if (!chain) return;
         const properties = this._chainSideProperties.get(chainKey);
-        if (nodeIndexes) {
-            textWriterObjs.forEach((writer) => {
-                nodeIndexes.forEach((i) => {
-                    writer.insertText(chain[i], i, chain, properties);
-                });
-            });
-            return;
-        }
         textWriterObjs.forEach((writer) => {
-            const chain = this._chainMap.get(chainKey);
-            const properties = this._chainSideProperties.get(chainKey);
+
             writer.insertTextBulk(chain, properties);
         });
 

package/circle-line-chain/plugin.js

@@ -21,6 +21,16 @@ import { keyMethod } from './util';
  * 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 {
@@ -28,7 +38,7 @@ export class CircleLineChainPlugin {
     constructor(id, { drawCircleOn = true, textContextWriterInjectionMap = new Map() } = {}) {
         this.id = id;
         this._textContextWriterInjectionMap = textContextWriterInjectionMap;
-        this._textContextWriterInjectionMap.forEach((writer) => writer.setKeyAdaptor((v, i, c, probs) => v.__identity__));
+        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 });
@@ -64,7 +74,10 @@ export class CircleLineChainPlugin {
                     }],
                     ["rgba", {
                         'bufferManager': new BufferManager(gl, 4, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array(item.rgba)
+                        '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 }),
@@ -72,27 +85,38 @@ export class CircleLineChainPlugin {
                     }],
                     ["dashRatio", {
                         'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.dashRatio])
+                        'adaptor': (item) => new Float32Array([item.chainProperties.dashRatio])
                     }],
 
                     ["dashOpacity", {
                         'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.dashOpacity])
+                        'adaptor': (item) => new Float32Array([item.chainProperties.dashOpacity])
                     }],
                     ["circleDashAngle", {
                         'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.circleDashAngle / 360])
+                        '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) {
+                console.log(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", "rgba", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key))));
+                ...["centerCoords", "bigRadius", "rgbaCircle", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key))));
         }
 
     }
@@ -127,7 +151,7 @@ export class CircleLineChainPlugin {
         for (const chain of data) {
             chainKeys.push(chain.chainKey);
             chain.nodes.forEach((node) => {
-                this._chainListMap.updateNode(node, chain.chainKey);
+                this._chainListMap.updateCoordsinatesOfNode(node, chain.chainKey);
             });
         }
         this._reconstructChains(chainKeys);
@@ -152,16 +176,15 @@ export class CircleLineChainPlugin {
      * @param {Array<chain>} data 
      * @typedef chain
      * @property {string} chainKey
-     * @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
+     * @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,
@@ -169,11 +192,9 @@ export class CircleLineChainPlugin {
         // let _reconstractChainBufferData method interact with data and bufferOrchestrator.
         const chainKeysToConstruct = [];
 
-        for (const { chainKey, rgba, dashOpacity, dashRatio, circleDashAngle, nodes } of data) {
+        for (const { chainKey, chainProperties, nodes } of data) {
             this._chainListMap.setChain(chainKey, nodes);
-            this._chainListMap.setChainProperties(chainKey, {
-                rgba, dashOpacity, dashRatio, circleDashAngle, chainKey
-            });
+            this._chainListMap.setChainProperties(chainKey, chainProperties);
             chainKeysToConstruct.push(chainKey);
         }
         this._reconstructChains(chainKeysToConstruct);
@@ -271,18 +292,17 @@ export class CircleLineChainPlugin {
         // }   
 
         const radiusM = radiusMethod(globe);
-        const callback = (v, i, array, probs) => {
+        const callback = (v, i, array, chainProperties) => {
             if (i == array.length - 1) return null;
             return {
-                rgba: probs.rgba,
+                chainProperties: chainProperties,
                 bigRadius: radiusM(v, i, array),
-                circleDashAngle: probs.circleDashAngle,
-                dashOpacity: probs.dashOpacity,
-                dashRatio: probs.dashRatio,
-                long: v.long,
-                lat: v.lat,
                 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__
             }
         }

package/package.json

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

package/rangerings/rangeringangletext.js

@@ -292,7 +292,7 @@ export default class RangeRingAngleText {
 
 
 
-    showAllVisiableCircleText() {
+    showAllVisibleCircleText() {
         this._hideAll = false;
         const addBucket = {
             coords: [],

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

@@ -54,6 +54,7 @@ export class BufferManager {
         const offsetMultiplier = itemSize * 4;
         for (let i = 0; i < blocks.length; i++) {
             const block = blocks[i];
+            console.log(block)
             const offset = offsets[i] * offsetMultiplier;
             if (offset !== undefined) gl.bufferSubData(gl.ARRAY_BUFFER, offset, block);
         }