@pirireis/webglobeplugins 0.5.9 → 0.5.10

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

@@ -116,7 +116,7 @@ export class ChainListMap {
         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;
 
     }
 
@@ -190,7 +190,7 @@ export class ChainListMap {
             const node = chain[i];
             this._indexMap.set(key, i);
             if (node.key === nodeKey) {
-                return i
+                return i;
             }
         }
     }

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.9",
+    "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)
+    }
+})

package/write-text/context-text2.js

@@ -104,7 +104,21 @@ export class ContextTextWriter2 {
         })
     }
 
+    updateTextCoords(item, i, container, properties) {
+        const coords = this.coordinatesAdaptor(item, i, container, properties);
+        if (coords == null) return;
+        const key = this.keyAdaptor(item, i, container, properties);
+        const data = this.itemMap.get(key)
+        data.angle = this.angleAdaptor(item, i, container, properties);
+        data.long = coords.long;
+        data.lat = coords.lat;
+    }
 
+    updateTextCoordsBulk(container, properties) {
+        container.forEach((v, i, c) => {
+            this.updateTextCoords(v, i, c, properties)
+        })
+    }
 
     deleteTextBulk(keys) {
         for (const key of keys) {