@pirireis/webglobeplugins 0.7.1 → 0.7.3

package/package.json

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

package/point-heat-map/plugin-webworker.js

@@ -16,26 +16,14 @@ class PointHeatmapPlugin {
         this._legendTexture = null;
 
         this._throttleListener = null;
-
-        try {
-
-            this.timeTrackInterpolationWorker = new Worker(
-                new URL(
-                    '../util/interpolation/timetrack/web-worker.js',
-                    import.meta.url
-                ), { type: 'module' }
-            );
-        } catch (e) {
-            console.log(e);
-            const blob = new Blob([webworkerStr], { type: 'application/javascript' });
-            this.timeTrackInterpolationWorker = new Worker(URL.createObjectURL(blob), { type: 'module' });
-        }
+        const blob = new Blob([webworkerStr], { type: 'application/javascript' });
+        this.timeTrackInterpolationWorker = new Worker(URL.createObjectURL(blob), { type: 'module' });
         this.timeTrackInterpolationWorker.onmessage = (e) => {
             if (e.data.error) {
                 throw new Error(e.data.error);
             }
             if (e.data === true) {
-                onInterpolationComplete()
+                onInterpolationComplete();
             }
             if (e.data instanceof Float32Array) {
                 this.flow.setData(e.data);

package/point-heat-map/point-to-heat-map-flow.js

@@ -13,7 +13,7 @@ class PointHeatmapFlow {
         this.gl = globe.gl;
         this.pointToDensityProgram = pointToDensityTextureCache.get(globe);
         this.densityToLegendProgram = densityToLegendProgramCache.get(globe);
-        this.testTextureProgram = textureOnCanvasProgramCache.get(globe);
+        // this.testTextureProgram = textureOnCanvasProgramCache.get(globe);
         this._lookInfo = globe.api_GetCurrentLookInfo();
         const { gl } = this;
         {
@@ -51,11 +51,11 @@ class PointHeatmapFlow {
             gl.bindFramebuffer(gl.FRAMEBUFFER, null);
         }
         defaultblendfunction(gl);
-        gl.viewport(0, 0, 400, 400);
-        this.testTextureProgram.draw(legendTexture, 1.0);
-        gl.viewport(0, 400, 400, 400);
-        this.testTextureProgram.draw(this.densityTexture, 1.0);
-        gl.viewport(0, 0, globe.api_ScrW(), globe.api_ScrH());
+        // gl.viewport(0, 0, 400, 400);
+        // this.testTextureProgram.draw(legendTexture, 1.0);
+        // gl.viewport(0, 400, 400, 400);
+        // this.testTextureProgram.draw(this.densityTexture, 1.0);
+        // gl.viewport(0, 0, globe.api_ScrW(), globe.api_ScrH());
         this._drawLegend(legendTexture, opacity);
     }
 

package/point-tracks/key-methods.js

@@ -0,0 +1,3 @@
+const pointKeyMeyhod = (trackId, pointID) => `${trackId}-${pointID}`;
+
+export { pointKeyMeyhod };

package/point-tracks/plugin.js

@@ -0,0 +1,80 @@
+import { BufferOrchestrator, BufferManager } from "../util/account";
+
+
+/**
+ * 
+ * @typedef { long ,lat, height, ID } Point
+ * @typedef {Array<Point>, rgba, TrackID} Track
+ */
+
+class PointTracksPlugin {
+
+    constructor(id, { } = {}) {
+        this.id = id;
+        this._isFreed = false;
+        this._tracksInfoMap = new Map();
+
+        this.program = null
+    }
+
+
+    init(globe, gl) {
+
+        this.globe = globe;
+        this.gl = gl;
+
+        this._initBufferManagers();
+    }
+
+    _initBufferManagers() {
+
+
+        const { gl } = this;
+        const initialCapacity = 10;
+
+        this._bufferOrchestrator = new BufferOrchestrator({ initialCapacity });
+        this._bufferManagersMap = new Map(
+            [
+                ["pos3D", new BufferManager(gl, 3, { bufferType: gl.ARRAY_BUFFER, initialCapacity })],
+                ["pos2D", new BufferManager(gl, 2, { bufferType: gl.ARRAY_BUFFER, initialCapacity })],
+                ["rgba", new BufferManager(gl, 4, { bufferType: gl.ARRAY_BUFFER, initialCapacity })],
+            ]
+        );
+
+        this._vao = this.program.createVAO(
+            this._bufferManagersMap.get("pos3D"),
+            this._bufferManagersMap.get("pos2D"),
+            this._bufferManagersMap.get("rgba"),
+        );
+
+
+    }
+
+
+
+    /**
+     * 
+     * @param {Array<Track>} tracks 
+     *
+     * @returns 
+     */
+    insertBulk(tracks) {
+        const { _bufferManagersMap, _bufferOrchestrator, _tracksInfoMap } = this;
+
+        const { pos3DIndex, pos2DIndex, rgbaIndex } = _bufferOrchestrator.insertBulk(tracks);
+        const trackID = tracks[0].trackID;
+        _tracksInfoMap.set(trackID, { pos3DIndex, pos2DIndex, rgbaIndex });
+        return trackID;
+    }
+
+
+    free() {
+        if (this._isFreed) return;
+        this._isFreed = true;
+    }
+
+
+
+
+
+}

package/programs/point-on-globe/square-pixel-point.js

@@ -0,0 +1,148 @@
+import { createProgram } from "../../util";
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
+import { mercatorXYToGLPosition, cartesian3DToGLPosition } from "../../util/shaderfunctions/geometrytransformations";
+import { noRegisterGlobeProgramCache } from "../programcache";
+
+
+const vs = `#version 300 es
+${CameraUniformBlockString}
+${mercatorXYToGLPosition}
+${cartesian3DToGLPosition}
+precision highp float;
+precision highp int;
+
+uniform int hovered_instanceID;
+
+in vec3 pos3D;
+in vec2 pos2D;
+in vec4 rgba;
+
+
+flat out highp int vInstanceID;
+
+
+out vec4 v_rgba;
+
+void main() {
+
+    if(is3D){
+        gl_Position = cartesian3DToGLPosition(pos3D);
+    }
+    else{
+        gl_Position = mercatorXYToGLPosition(pos2D);
+    }
+    if (hovered_instanceID == gl_InstanceID) {
+        gl_PointSize = 3.0;
+    } else {
+        gl_PointSize = 1.0;
+    v_rgba = rgba;
+}`;
+
+const fs = `#version 300 es
+precision highp float;
+
+uniform opacity;
+
+flat in highp int vInstanceID;
+
+in vec4 v_rgba;
+
+layout(location = 0) out vec4 fragColor;
+layout(location = 1) out int instanceID;
+
+void main() {
+    fragColor = v_rgba;
+    fragColor.a *= opacity;
+    instanceID = vInstanceID; 
+}`;
+
+
+class PointOnGlobeProgram {
+
+    constructor(globe) {
+
+        this.globe = globe;
+        this.gl = globe.gl;
+
+        this.program = createProgram(this.gl, vs, fs);
+
+        const { gl, program } = this;
+
+        this.uniforms = {
+            opacity: gl.getUniformLocation(program, "opacity"),
+        }
+
+        { // assign attribute locations
+            gl.bindAttribLocation(program, 0, "pos3D");
+            gl.bindAttribLocation(program, 1, "pos2D");
+            gl.bindAttribLocation(program, 2, "rgba");
+        }
+
+        { // arrange camera uniform block
+            this.cameraBlockBingingPoint = 0;
+            this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+            const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+            gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBingingPoint);
+        }
+    }
+
+
+    createVAO(pos3DBuffer, pos2DBuffer, rgbaBuffer) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+
+        {
+            gl.bindBuffer(gl.ARRAY_BUFFER, pos3DBuffer);
+            gl.enableVertexAttribArray(0);
+            gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
+        }
+        {
+            gl.bindBuffer(gl.ARRAY_BUFFER, pos2DBuffer);
+            gl.enableVertexAttribArray(1);
+            gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 0, 0);
+        }
+        {
+            gl.bindBuffer(gl.ARRAY_BUFFER, rgbaBuffer);
+            gl.enableVertexAttribArray(2);
+            gl.vertexAttribPointer(2, 4, gl.FLOAT, false, 0, 0);
+        }
+
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+    }
+
+    draw(vao, length, { opacity = 1.0, frameBuffer = null } = {}) {
+        if (length === 0 || opacity === 0) return;
+        const { gl, program, uniforms } = this;
+        gl.useProgram(program);
+        gl.uniform1f(uniforms.opacity, opacity);
+        gl.bindVertexArray(vao);
+        if (frameBuffer) {
+            gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
+            gl.
+                gl.drawArrays(gl.POINTS, 0, length);
+        }
+        this.cameraBlockTotem.bind(this.cameraBlockBingingPoint);
+        gl.drawArrays(gl.POINTS, 0, length);
+        this.cameraBlockTotem.unbind(this.cameraBlockBingingPoint);
+        gl.bindVertexArray(null);
+    }
+
+    free() {
+        if (this._isFreed) return;
+        const { gl, globe } = this;
+        CameraUniformBlockTotemCache.release(globe);
+        gl.deleteProgram(this.program);
+        this._isFreed = true;
+    }
+}
+
+
+const pointOnGlobeProgramCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, PointOnGlobeProgram),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, PointOnGlobeProgram)
+});
+
+export { pointOnGlobeProgramCache };

package/timetracks/program-line-strip.js

@@ -190,36 +190,36 @@ export default class TrackGlowLineProgram {
         const gl = this.gl;
 
         const vertexShader = `#version 300 es
-        precision highp float;
+precision highp float;
 
-        in vec2 a_position;
+in vec2 a_position;
 
-        out vec2 v_texcoord;
+out vec2 v_texcoord;
 
-        void main() {
-            gl_Position = vec4(a_position, 0.0, 1.0);
-            v_texcoord = a_position.xy * 0.5 + 0.5;
-        }
+void main() {
+    gl_Position = vec4(a_position, 0.0, 1.0);
+    v_texcoord = a_position.xy * 0.5 + 0.5;
+}
         `;
 
         const fragmentShader = `#version 300 es
-        precision highp float;
+precision highp float;
 
-        in vec2 v_texcoord;
+in vec2 v_texcoord;
 
-        uniform sampler2D u_main_texture;
-  
+uniform sampler2D u_main_texture;
 
-        uniform float u_final_alpha_ratio;
 
-        out vec4 outColor;
+uniform float u_final_alpha_ratio;
 
-        void main() {
+out vec4 outColor;
 
-            vec4 hdrColor = texture(u_main_texture, v_texcoord);      
-            outColor = hdrColor;
-            outColor.a *= u_final_alpha_ratio;
-        }
+void main() {
+
+    vec4 hdrColor = texture(u_main_texture, v_texcoord);      
+    outColor = hdrColor;
+    outColor.a *= u_final_alpha_ratio;
+}
         `;
         const program = createProgram(this.gl, vertexShader, fragmentShader);
 
@@ -253,41 +253,41 @@ export default class TrackGlowLineProgram {
         const gl = this.gl;
 
         const vertexShader = `#version 300 es
-        precision highp float;
+precision highp float;
 
-        in vec2 a_position;
+in vec2 a_position;
 
-        out vec2 v_texcoord;
+out vec2 v_texcoord;
 
-        void main() {
-            gl_Position = vec4(a_position, 0.0, 1.0);
-            v_texcoord = a_position.xy * 0.5 + 0.5;
-        }
+void main() {
+    gl_Position = vec4(a_position, 0.0, 1.0);
+    v_texcoord = a_position.xy * 0.5 + 0.5;
+}
         `;
 
         const fragmentShader = `#version 300 es
-        precision highp float;
+precision highp float;
 
-        in vec2 v_texcoord;
+in vec2 v_texcoord;
 
-        uniform sampler2D u_main_texture;
-        uniform sampler2D u_bloom_texture;
+uniform sampler2D u_main_texture;
+uniform sampler2D u_bloom_texture;
 
-        uniform float u_exposure;
-        uniform float u_gamma;
-        uniform float u_final_alpha_ratio;
+uniform float u_exposure;
+uniform float u_gamma;
+uniform float u_final_alpha_ratio;
 
-        out vec4 outColor;
+out vec4 outColor;
 
-        void main() {
+void main() {
 
-            vec4 hdrColor = texture(u_main_texture, v_texcoord);      
-            vec4 bloomColor =  texture(u_bloom_texture, v_texcoord);
-            vec4 result = hdrColor + bloomColor * u_exposure;
-            result = pow(result, vec4(1.0 / u_gamma));
-            result.a *= u_final_alpha_ratio;
-            outColor = result;
-        }
+    vec4 hdrColor = texture(u_main_texture, v_texcoord);      
+    vec4 bloomColor =  texture(u_bloom_texture, v_texcoord);
+    vec4 result = hdrColor + bloomColor * u_exposure;
+    result = pow(result, vec4(1.0 / u_gamma));
+    result.a *= u_final_alpha_ratio;
+    outColor = result;
+}
         `;
         const program = createProgram(this.gl, vertexShader, fragmentShader);
 
@@ -577,7 +577,7 @@ void main() {
 
         const texture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, texture);
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _width, _height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null); // UNSIGNED_BYTE
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, _width, _height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null); // UNSIGNED_BYTE
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
@@ -589,11 +589,11 @@ void main() {
     _resetTexture() {
         const { gl, _width, _height } = this;
         gl.bindTexture(gl.TEXTURE_2D, this._middleTexture); // UNSIGNED_BYTE
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _width, _height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, _width, _height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
         gl.bindTexture(gl.TEXTURE_2D, this._blurTextures[0]);
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _width, _height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, _width, _height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
         gl.bindTexture(gl.TEXTURE_2D, this._blurTextures[1]);
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _width, _height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, _width, _height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
         gl.bindTexture(gl.TEXTURE_2D, null);
     }
 

package/util/interpolation/timetrack/web-worker-str.js

@@ -160,6 +160,11 @@ self.onmessage = function (e) {
     if (time !== null) {
         try {
             const result = interpolator.interpolate(time);
+            if(result === null) {
+                /* eslint-disable-next-line no-restricted-globals */
+                self.postMessage({ error: 'No TimeTracks Data' });
+                return;
+            }
             /* eslint-disable-next-line no-restricted-globals */
             self.postMessage(result, [result.buffer]);
             return;

package/util/interpolation/timetrack/web-worker.js

@@ -31,6 +31,11 @@ self.onmessage = function (e) {
     if (time !== null) {
         try {
             const result = interpolator.interpolate(time);
+            if (result === null) {
+                /* eslint-disable-next-line no-restricted-globals */
+                self.postMessage({ error: 'No TimeTracks Data' });
+                return;
+            }
             /* eslint-disable-next-line no-restricted-globals */
             self.postMessage(result, [result.buffer]);
             return;