@pirireis/webglobeplugins 0.5.8 → 0.5.10

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

@@ -95,22 +95,28 @@ export class ChainListMap {
     }
 
 
-    updateNodeProperties(node, chainKey) {
-        const index = this.getIndexOfNode(chainKey, node.key)
-        const chainNode = this._chainMap.get(chainKey)[index];
-        if (node.circleProperties) {
-            node.circleProperties.forEach((value, key, container) => chainNode[key] = value);
-        }
-        if (node.lineProperties) {
-            node.lineProperties.forEach((value, key, container) => chainNode[key] = value);
-        }
+    updateNodesProperties(chainKey, nodes) {
+        nodes.forEach((node) => {
+
+            const index = this.getIndexOfNode(chainKey, node.key)
+            const chainNode = this._chainMap.get(chainKey)[index];
+            if (node.circleProperties) {
+                if (chainNode.circleProperties === undefined) chainNode.circleProperties = {}
+                node.circleProperties.forEach((value, key, container) => chainNode.circleProperties[key] = value);
+            }
+            if (node.lineProperties) {
+                if (chainNode.lineProperties === undefined) chainNode.lineProperties = {}
+                node.lineProperties.forEach((value, key, container) => chainNode.lineProperties[key] = value);
+            }
+        });
+
     }
 
     updateCoordsinatesOfNode(node, chainKey) {
         const index = this.getIndexOfNode(chainKey, node.key)
         const chain = this._chainMap.get(chainKey);
         chain[index].long = node.long;
-        chain[index].long = node.lat;
+        chain[index].lat = node.lat;
 
     }
 
@@ -179,13 +185,12 @@ export class ChainListMap {
     getIndexOfNode(chainKey, nodeKey) {
         const key = this.keyMethod(chainKey, nodeKey);
         if (this._indexMap.has(key)) return this._indexMap.get(key);
-
         const chain = this._chainMap.get(chainKey);
         for (let i = 0; i < chain.length; i++) {
             const node = chain[i];
             this._indexMap.set(key, i);
             if (node.key === nodeKey) {
-                return i
+                return i;
             }
         }
     }

package/circle-line-chain/plugin.js

@@ -161,12 +161,12 @@ export class CircleLineChainPlugin {
     /**
      * 
      * @param {*} chainKey 
-     * @param {Array<{nodeKey, Map[propertyName ,value]}} propertyMap 
+     * @param {Array<{nodeKey, circleProperties:Map[propertyName ,value],  lineProperties:Map[propertyName ,value] }} propertyMap 
      */
-    updateNodeProperties(chainKey, nodesAndPropertyMap, { textWriterIDs = [] } = {}) {
-        this._chainListMap.updateNodeProperties(chainKey, nodesAndPropertyMap)
+    updateNodesProperties(chainKey, nodesAndPropertyMap, { textWriterIDs = [] } = {}) {
+        this._chainListMap.updateNodesProperties(chainKey, nodesAndPropertyMap)
         this._reconstructChains([chainKey]);
-        this._updateTexts(chainKey, textWriterIDs);
+        this._updateTexts([chainKey], textWriterIDs);
         this.globe.DrawRender();
     }
 
@@ -231,7 +231,7 @@ export class CircleLineChainPlugin {
 
 
     updateNodeCoordinates(node, chainKey, { textWriterIDs = [] } = {}) {
-        this._chainListMap.updateNode(node, chainKey);
+        this._chainListMap.updateCoordsinatesOfNode(node, chainKey);
         if (textWriterIDs) this._updateTexts([chainKey], textWriterIDs);
         this._reconstructChains([chainKey]);
         this.globe.DrawRender();
@@ -273,17 +273,18 @@ export class CircleLineChainPlugin {
      * 
      * @param {Array<{chainKey, nodeKeys:[]} keysAndNodes
      */
-    deleteNodes(keysAndNodes) {
+    deleteNodes(keysAndNodes, { textWriterIDs = [] } = {}) {
         const bufferKeys = [];
         const chainKeysToReconstuct = [];
         keysAndNodes.forEach(({ chainKey, nodeKeys }) => {
             bufferKeys.push(...this._chainListMap.deleteNodesBelongToAChain(chainKey, nodeKeys));
             chainKeysToReconstuct.push(chainKey);
         });
-        this._reconstructChains(chainKeysToReconstuct);
         this._textContextWriterInjectionMap.forEach((writer) => writer.deleteTextBulk(bufferKeys));
         // if (textWriterIDs) this._updateTexts(chainKeysToReconstuct, textWriterIDs)
         this.bufferOrchestrator.deleteBulk(bufferKeys, this.bufferManagersCompMap);
+        this._reconstructChains(chainKeysToReconstuct);
+        this._updateTexts(chainKeysToReconstuct, textWriterIDs);
         this.globe.DrawRender();
 
     }

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

@@ -0,0 +1,76 @@
+import { PixelPaddingForFlatCompassCache } from "../programs/two-d/pixel-padding-for-compass";
+
+
+
+export class PixelPaddingCompassPlugin {
+    constructor(id, { } = {}) {
+        this.id = id;
+        this.memory = new Map();
+
+    }
+
+    init(globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+
+        this._initOrchestrations()
+    }
+
+
+
+    _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) => {
+                            const { x, y } = globe.api_GetScreenPointFromGeo(
+                                {
+                                    long: item.long,
+                                    lat: item.lat,
+                                    z: 0,
+                                });
+                            return new Float32Array([x, y]);
+                        }
+                    }],
+                    ["pixelRadiusSmall", {
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.pixelRadiusSmall])
+                    }],
+                    ["pixelRadiusBig", {
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.pixelRadiusBig])
+                    }],
+                    ["rgba", {
+                        'bufferManager': new BufferManager(gl, 4, { bufferType, initialCapacity }),
+                        'adaptor': (item) => {
+                            if (item.lineProperties?.rgba) return new Float32Array(item.lineProperties.rgba);
+                            return new Float32Array(item.rgba);
+                        }
+                    }],
+
+                ]
+            );
+            const obj = function (bufferManagerComp) {
+                return { 'buffer': bufferManagerComp.bufferManager.buffer, 'stride': 0, 'offset': 0 }
+            };
+            this.paddingVao = this.paddingProgram.createVAO(
+                ...['screenCoordinates', 'pixelRadiusSmall', 'pixelRadiusBig', 'rgba'].map(key => obj(this.bufferManagersCompMap.get(key))));
+        }
+
+    }
+}
+
+
+
+
+function isOnTheScreen(globe, points) { }
+

package/package.json

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

package/programs/two-d/pixel-padding-for-compass.js

@@ -0,0 +1,155 @@
+import { createProgram } from "../../util";
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
+import { globeProgramCache } from "../programcache";
+const vertexCount = 720;
+const vertexShaderSource = `#version 300 es
+${CameraUniformBlockString}
+in vec2 screen_coordinate;
+in float pixel_radius_small;
+in float pixel_radius_big;
+in vec4 rgba;
+
+out vec4 v_rgba;
+
+uniform float world_angle_radiance;
+uniform float plugin_opacity;
+
+vec2 coords(){
+    float radius;
+    float angle;
+    if( gl_VertexID % 2 == 0){
+        if ( gl_VertexID % 60 == 0){
+            radius = pixel_radius_small;
+        } else {
+            radius = (pixel_radius_big + pixel_radius_small) / 2.0;
+        }
+        angle = (float(gl_VertexID) / (${vertexCount}.0));
+
+    } else {
+        radius = pixel_radius_big;
+        angle = (float(gl_VertexID - 1) / (${vertexCount}.0));
+    }
+    angle *= ${Math.PI * 2.0} + world_angle_radiance;
+    return screen_coordinate + vec2( cos(angle), sin(angle)) * radius;
+}
+
+
+void main(){
+    vec2 c = coords();
+    gl_Position = vec4( vec2(c.x / screenWH.x, c.y/ screenWH.y), 0.0,1.0);
+    v_rgba = rgba;
+    v_rgba.a *= plugin_opacity;
+}
+`
+
+const fragmentShaderSource = `#version 300 es
+precision highp float;
+in vec4 v_rgba;
+out vec4 color;
+void main(){
+    color = v_rgba;
+}
+`
+
+
+class Logic {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._lastOpacity = 1;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+        const { gl, program } = this;
+        { // assign attribute locations
+            gl.bindAttriblocation(program, 0, "screen_coordinate");
+            gl.bindAttriblocation(program, 1, "pixel_radius_small");
+            gl.bindAttriblocation(program, 2, "pixel_radius_big");
+            gl.bindAttriblocation(program, 3, "rgba");
+        }
+        {
+            this._opacityLocation = gl.getUniformLocation(program, "plugin_opacity");
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(this._opacityLocation, this._lastOpacity);
+            gl.useProgram(currentProgram);
+        }
+        {
+            this.cameraBlockBindingPoint = 0;
+            const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+            this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+            gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
+        }
+    }
+
+
+    draw(vao, length, opacity) {
+        const { globe, gl, program, cameraBlockTotem, cameraBlockBindingPoint, _opacityLocation } = this;
+        if (globe.api_GetCurrentGeometry() === 0) return;
+        gl.useProgram(program);
+        cameraBlockTotem.bind(cameraBlockBindingPoint);
+        gl.bindVertexArray(vao);
+        if (opacity !== this._lastOpacity) {
+            this._lastOpacity = opacity;
+            gl.uniform1f(_opacityLocation, opacity);
+        }
+        gl.drawArraysInstanced(gl.LINES, 0, vertexCount, length);
+        gl.bindVertexArray(null);
+        cameraBlockTotem.unbind(cameraBlockBindingPoint);
+    }
+
+    createVAO(screenCoordsBufferObj, pixelRadiusSmallBufferObj, pixelRadiusBigBufferObj, rgbaBufferObj) {
+        const { gl } = this;
+
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        {
+            const { buffer, stride = 0, offset = 0 } = screenCoordsBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(0);
+            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(0, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = pixelRadiusSmallBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(0);
+            gl.vertexAttribPointer(1, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(1, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = pixelRadiusBigBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(0);
+            gl.vertexAttribPointer(2, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(2, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = rgbaBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(0);
+            gl.vertexAttribPointer(3, 4, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(3, 1);
+        }
+
+        gl.bindVertexArray(null);
+        return vao;
+
+    }
+
+
+
+
+    free() {
+        CameraUniformBlockTotemCache.release(globe);
+    }
+}
+
+
+
+export const PixelPaddingForFlatCompassCache = Object.freeze({
+    get: (globe) => {
+        globeProgramCache.getProgram(globe, Logic)
+    },
+    release: (globe) => {
+        globeProgramCache.releaseProgram(globe, Logic)
+    }
+})