@pirireis/webglobeplugins 0.10.9-alpha → 0.10.11-alpha

package/package.json

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

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

@@ -1,5 +1,4 @@
 import { PointHeatmapFlow } from "./point-to-heat-map-flow";
-// import { webworkerStr } from "../util/interpolation/timetrack/web-worker-str"; // TODO: Delete When this plugin is tested on production
 import { createWorker } from "../util/interpolation/timetrack/index";
 import { createTexture, getColorRampModed } from "../util";
 import { opacityCheck, constraintFloat } from "../util/check/typecheck";
@@ -15,8 +14,6 @@ class PointHeatmapPlugin {
         this._legendTexture = null;
         this._throttleListener = null;
         this._timeTracksAreSet = false;
-        // const blob = new Blob([webworkerStr], { type: 'application/javascript' });
-        // this.timeTrackInterpolationWorker = new Worker(URL.createObjectURL(blob), { type: 'module' });
         this.timeTrackInterpolationWorker = createWorker();
         this.timeTrackInterpolationWorker.onmessage = (e) => {
             if (e.data.error) {

package/programs/rings/distancering/circlepaddingfreeangleprogram.js

@@ -161,19 +161,9 @@ export class BufferManager extends BufferOffsetManager {
             gl.bindVertexArray(null);
         }
     }
-    __centerMapMethod(rings, paddingAngles) {
-        return new Map([
-            ["rings", rings],
-            ["paddingAngles", paddingAngles]
-        ]);
-    }
     bindPaddingVAO() {
         this.gl.bindVertexArray(this.vao);
     }
-    //TODO: implement this
-    // insertBulk is gone. no update feature
-    // addBulk is added.
-    // deletes old centers given 
     insertBulk(data) {
         const { gl, buffer } = this;
         const deleteCentersList = [];
@@ -233,7 +223,6 @@ export class BufferManager extends BufferOffsetManager {
         }
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
     }
-    //TODO: test
     updateCentersHide(data) {
         const { gl, buffer } = this;
         const items = [];
@@ -275,14 +264,6 @@ export class BufferManager extends BufferOffsetManager {
         }
         this._updatePartial(items, 4, gl, buffer);
     }
-    __requiredSpaceForBulk(data) {
-        let space = 0;
-        for (const { paddingAngles, rings } of data) {
-            space += paddingAngles.length * rings.length;
-        }
-        return space;
-    }
-    // TODO: TEST IT WITH INSERT
     removeCenters(centerIDs) {
         const keys = [];
         for (const centerID of centerIDs) {
@@ -300,6 +281,19 @@ export class BufferManager extends BufferOffsetManager {
         }
         this._removeFromBuffer(keys);
     }
+    __requiredSpaceForBulk(data) {
+        let space = 0;
+        for (const { paddingAngles, rings } of data) {
+            space += paddingAngles.length * rings.length;
+        }
+        return space;
+    }
+    __centerMapMethod(rings, paddingAngles) {
+        return new Map([
+            ["rings", rings],
+            ["paddingAngles", paddingAngles]
+        ]);
+    }
 }
 const offsetMapKey = (centerID, ringID, paddingAngle) => `${centerID}_${ringID}_${paddingAngle}`;
 /**

package/timetracks/index.js

@@ -1,5 +1,3 @@
-import TimeTracks from './plugin';
-import { Adaptor, fillSliceOfFloat32Array, createFloat32Array } from './adaptors';
 import TimeTracksLineStrip from './plugin-line-strip';
 import { addCuttingPointLineStrip, featuresToLineStringData, fillSliceOfFloat32ArrayLineStrip, latLongToPixelXY } from './adaptors-line-strip';
 export { Adaptor, fillSliceOfFloat32Array, createFloat32Array, TimeTracks, TimeTracksLineStrip, addCuttingPointLineStrip, featuresToLineStringData, fillSliceOfFloat32ArrayLineStrip, latLongToPixelXY };

package/util/heatwavedatamanager/index.js

@@ -1,3 +1,2 @@
-import PointCoordinatesDataCalculator1 from "./pointcoordinatesdatacalculator1";
 import HeatWaveDataManager from "./datamanager";
-export { HeatWaveDataManager, PointCoordinatesDataCalculator1 }; // TODO: delete pointcoordinatesdatacalculator1.js
+export { HeatWaveDataManager };

package/util/heatwavedatamanager/texture-point-sampler.js

@@ -122,6 +122,7 @@ export class TexturePointSampler {
         const { posIndex, callback } = pointObject;
         if (posIndex === -1 || !this._isReady || this._ratio < 0 || this._ratio > 1) {
             callback(null, null, null);
+            return;
         }
         const data0 = this._textures[0][posIndex];
         if (this._textureCount === 1) {

package/waveparticles/plugin.js

@@ -16,7 +16,7 @@ const { PingPongBufferManager, WaveParticalUboManager } = vectorfield;
  */
 const MAX_PIXELS_ON_DIMENSION = 2200;
 export default class Plugin {
-    constructor(id, { dataWidth, dataHeight, fadeOpacity = 0.83, opacity = 0.75, minLon = -180, minLat = -90, maxLon = 180, maxLat = 90, escapeValue = -9999, patricleCount = 8000, flipY = true, drawTextureMaxPixelOnDimension = MAX_PIXELS_ON_DIMENSION } = {}) {
+    constructor(id, { dataWidth, dataHeight, fadeOpacity = 0.83, opacity = 0.75, minLon = -180, minLat = -90, maxLon = 180, maxLat = 90, patricleCount = 8000, flipY = true, drawTextureMaxPixelOnDimension = MAX_PIXELS_ON_DIMENSION } = {}) {
         this.id = id;
         this.globe = null;
         this.gl = null;
@@ -34,7 +34,6 @@ export default class Plugin {
         this._particleCount = patricleCount;
         this._dataWidth = dataWidth;
         this._dataHeight = dataHeight;
-        this._escapeValue = escapeValue;
         this._drawTextureMaxPixelOnDimension = drawTextureMaxPixelOnDimension;
         this._globeshellparameters = {
             minLon,
@@ -61,7 +60,6 @@ export default class Plugin {
         this._frameBuffer = gl.createFramebuffer();
         this.setBBox(this._globeshellparameters);
         this.setOpacity(this._opacity);
-        this.setEscapeValue(this._escapeValue);
         this.____drawIndex = 0;
     }
     draw3D() {
@@ -167,14 +165,6 @@ export default class Plugin {
         this.waveUbo.updateSingle("drop_rate", new Float32Array([value]));
         ;
     }
-    setEscapeValue(value) {
-        if (typeof value !== 'number') {
-            console.error("escape value must be a number");
-            return;
-        }
-        this._escapeValue = value;
-        this.waveUbo.updateSingle("escape_value", value);
-    }
     setDrawTextureMaxPixelOnDimension(value) {
         this._drawTextureMaxPixelOnDimension = value;
         this._drawTextureResolution = this._drawTextureSizeFromBbox(this._globeshellparameters);

package/programs/globeshell/noise/noises.js

@@ -1 +0,0 @@
-"use strict";

package/programs/line-on-globe/angled-line.js

@@ -1,173 +0,0 @@
-// angle radius, rgba, dashRatio, rgbaMode
-import { createProgram } from "../../util";
-import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
-import { longLatRadToMercator, longLatRadToCartesian3D, cartesian3DToGLPosition, mercatorXYToGLPosition, circleLimpFromLongLatRadCenterCartesian3D, circleLimpFromLongLatRadCenterMercatorCompass, circleLimpFromLongLatRadCenterMercatorRealDistance, POLE } from "../../util/shaderfunctions/geometrytransformations";
-import { noRegisterGlobeProgramCache } from "../programcache";
-const EDGE_COUNT_ON_SPHERE = 50;
-const vertexShaderSource = `#version 300 es
-precision highp float;
-
-${CameraUniformBlockString}
-${longLatRadToMercator}
-${longLatRadToCartesian3D}
-${cartesian3DToGLPosition}
-${mercatorXYToGLPosition}
-${circleLimpFromLongLatRadCenterCartesian3D}
-${circleLimpFromLongLatRadCenterMercatorCompass}
-${circleLimpFromLongLatRadCenterMercatorRealDistance}
-
-in vec2 center_point;
-in float angle;
-in float radius;
-in vec4 rgba;
-in float dash_ratio;
-in float dash_opacity;
-
-out vec4 v_color;
-out float v_dash_ratio;
-out float interpolation;
-out float v_dash_opacity;
-out vec2 v_limp;
-// TODO: Draw World Boundaries 
-void main() {
-    if ( is3D ) {
-        interpolation = float( gl_VertexID ) / ${EDGE_COUNT_ON_SPHERE - 1}.0;
-        float radius_ = radius* interpolation;
-        vec3 position = circleLimpFromLongLatRadCenterCartesian3D( center_point, radius_, angle);
-        gl_Position = cartesian3DToGLPosition( position);
-        v_limp = vec2(0.0, 0.0);
-    } else {
-        interpolation = float( gl_VertexID );
-        float radius_ = radius * interpolation;
-        vec2 position = circleLimpFromLongLatRadCenterMercatorRealDistance( center_point, radius_, angle);
-        v_limp = position;
-        gl_Position = mercatorXYToGLPosition( position);
-    }
-    v_dash_opacity = dash_opacity;
-    v_color = rgba;
-    v_dash_ratio = dash_ratio;
-}`;
-const fragmentShaderSource = `#version 300 es
-${POLE}
-precision highp float;
-
-uniform float opacity;
-in vec4 v_color;
-in float v_dash_ratio;
-in float v_dash_opacity;
-in float interpolation;
-in vec2 v_limp;
-out vec4 color;
-
-void main() {
-    if ( v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE ){ color = vec4(0.0,0.0,0.0,0.0); return; }
-    color = vec4(v_color.rgb, v_color.a * opacity);
-    if (fract(interpolation / (2.0 * v_dash_ratio)) < 0.5 ) {
-        color.a *= v_dash_opacity;
-    }   
-}`;
-class Logic {
-    constructor(globe) {
-        this.globe = globe;
-        this.gl = globe.gl;
-        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
-        this._lastOpacity = 1;
-        const { gl, program } = this;
-        { // assign attribute locations
-            gl.bindAttribLocation(program, 0, "center_point");
-            gl.bindAttribLocation(program, 1, "angle");
-            gl.bindAttribLocation(program, 2, "radius");
-            gl.bindAttribLocation(program, 3, "rgba");
-            gl.bindAttribLocation(program, 4, "dash_ratio");
-            gl.bindAttribLocation(program, 5, "dash_opacity");
-        }
-        {
-            this._opacityLocation = gl.getUniformLocation(program, "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 { gl, program, globe, cameraBlockTotem, cameraBlockBindingPoint } = this;
-        gl.useProgram(program);
-        if (opacity !== this._lastOpacity) {
-            gl.uniform1f(this._opacityLocation, opacity);
-            this._lastOpacity = opacity;
-        }
-        const drawCount = globe.api_GetCurrentGeometry() === 0 ? EDGE_COUNT_ON_SPHERE : 2;
-        gl.bindVertexArray(vao);
-        cameraBlockTotem.bind(cameraBlockBindingPoint);
-        // gl.disable(gl.DEPTH_TEST);
-        gl.drawArraysInstanced(gl.LINE_STRIP, 0, drawCount, length);
-        gl.bindVertexArray(null);
-        cameraBlockTotem.unbind(cameraBlockBindingPoint);
-        // gl.enable(gl.DEPTH_TEST);
-    }
-    createVAO(centerCoords, angle, radius, rgba, dashRatio, dashOpacity) {
-        const { gl } = this;
-        const vao = gl.createVertexArray();
-        gl.bindVertexArray(vao);
-        {
-            const { buffer, stride = 0, offset = 0 } = centerCoords;
-            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 } = angle;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(1);
-            gl.vertexAttribPointer(1, 1, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(1, 1);
-        }
-        {
-            const { buffer, stride = 0, offset = 0 } = radius;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(2);
-            gl.vertexAttribPointer(2, 1, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(2, 1);
-        }
-        {
-            const { buffer, stride = 0, offset = 0 } = rgba;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(3);
-            gl.vertexAttribPointer(3, 4, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(3, 1);
-        }
-        {
-            const { buffer, stride = 0, offset = 0 } = dashRatio;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(4);
-            gl.vertexAttribPointer(4, 1, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(4, 1);
-        }
-        {
-            const { buffer, stride = 0, offset = 0 } = dashOpacity;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(5);
-            gl.vertexAttribPointer(5, 1, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(5, 1);
-        }
-        gl.bindVertexArray(null);
-        return vao;
-    }
-    free() {
-        if (this.isFreed)
-            return;
-        CameraUniformBlockTotemCache.release(this.globe);
-        this.cameraBlockTotem = null;
-        this.gl.deleteProgram(this.program);
-        this.isFreed = true;
-    }
-}
-export const AngledLineProgramCache = Object.freeze({
-    get: (globe) => { return noRegisterGlobeProgramCache.getProgram(globe, Logic); },
-    release: (globe) => { return noRegisterGlobeProgramCache.releaseProgram(globe, Logic); }
-});

package/timetracks/adaptors.js

@@ -1,117 +0,0 @@
-import { latLongToPixelXY } from "../util";
-const _latLongToPixelXY = latLongToPixelXY;
-class Adaptor {
-    /**
-     * @param {Object.<string, Color>} groupColorMap
-     * @typedef {Array} Color | [r, g, b] | between 0-1
-     */
-    constructor(groupColorMap) {
-        this._groupColorMap = groupColorMap;
-    }
-    /**
-     * @param {Object} geojsonObject
-     * @param {number} startTime
-     * @param {string} timePropertyName
-     * @param {string} styleGroupPropertyName
-     * @returns {lineData} lineData for Plugin
-     */
-    fromGeoJson(geojsonObject, startTime, timePropertyName = "messageTime", styleGroupPropertyName = "styleGroup") {
-        const features = geojsonObject.features.filter(feature => feature.geometry.coordinates.length > 1);
-        const buffer = createFloat32Array(features.map(feature => feature.geometry.coordinates));
-        let offset = 0;
-        for (let feature of features) {
-            const coordinates = feature.geometry.coordinates;
-            const timestamps = feature.properties[timePropertyName].map((time) => (time - startTime) / 1000);
-            const styleGroupNameArray = feature.properties[styleGroupPropertyName];
-            offset = fillSliceOfFloat32Array(coordinates, timestamps, styleGroupNameArray, this._groupColorMap, buffer, offset);
-        }
-        return buffer;
-    }
-    /**
-     * Inputs are lists of tracks. Each track is a list of coordinates, timestamps and styleGroupNames.
-     * @param {Array.<Array.<Array.<number>>>} coordinatesList | [ [ [lon, lat, z], [lon, lat, z], ...], ...
-     * @param {Array.<Array.<number>>} timestampsList | [ [time, time, ...], ...
-     * @param {Array.<Array.<String>>} colorGroupList | [ [styleGroupName, styleGroupName, ...], ...
-     * @param {number} startTime | epoch time
-     * @returns {lineData} lineData for Plugin
-     */
-    fromLists(coordinatesList, timestampsList, colorGroupList, startTime) {
-        const buffer = createFloat32Array(coordinatesList);
-        let offset = 0;
-        for (let i = 0; i < coordinatesList.length; i++) {
-            const coordinates = coordinatesList[i];
-            const timestamps = timestampsList[i].map((time) => (time - startTime) / 1000);
-            const styleGroupNameArray = colorGroupList[i];
-            offset = fillSliceOfFloat32Array(coordinates, timestamps, styleGroupNameArray, this._groupColorMap, buffer, offset);
-        }
-        return buffer;
-    }
-}
-/**
- * @param {Array.<Array.<number>>} coordinates
- * @param {Array.<number>} timestamps
- * @param {Array.<String>} styleGroupNameArray
- * @param {Object.<string, TrackStyleGroup>} _groupColorMap
- * @param {Float32Array} floatArray
- * @param {number} offset
- *
- * create floatArray with createFloat32Array before calling this function.
- * start offset from 0.
- * feed the floatArray with a track data and offset that is returned from the previous call.
- */
-function fillSliceOfFloat32Array(coordinates, timestamps, styleGroupNameArray, _groupColorMap, floatArray, offset) {
-    if (coordinates[0].length === 2) {
-        const startTime = timestamps[0];
-        const endTime = timestamps[timestamps.length - 1];
-        let prevPointData = null;
-        { // first point
-            const { x, y } = _latLongToPixelXY(coordinates[0][1], coordinates[0][0]);
-            prevPointData = [x, y, 0, timestamps[0], ..._groupColorMap[styleGroupNameArray[0]]];
-        }
-        { // middle points until end
-            for (let i = 1; i < coordinates.length; i++) {
-                const time = timestamps[i];
-                const coord = coordinates[i];
-                const { x, y } = _latLongToPixelXY(coord[1], coord[0]);
-                floatArray.set([...prevPointData, startTime, endTime, x, y, 0, time, ..._groupColorMap[styleGroupNameArray[i]], startTime, endTime], offset);
-                prevPointData = [x, y, 0, time, ..._groupColorMap[styleGroupNameArray[i]]];
-                offset += 18;
-            }
-        }
-    }
-    else {
-        const startTime = timestamps[0];
-        const endTime = timestamps[timestamps.length - 1];
-        let prevPointData = null;
-        { // first point
-            const { x, y } = _latLongToPixelXY(coordinates[0][1], coordinates[0][0]);
-            prevPointData = [x, y, coordinates[0][2] / 1000.0, timestamps[0], ..._groupColorMap[styleGroupNameArray[0]]];
-        }
-        { // middle points until end
-            for (let i = 1; i < coordinates.length; i++) {
-                const time = timestamps[i];
-                const coord = coordinates[i];
-                const { x, y } = _latLongToPixelXY(coord[1], coord[0]);
-                floatArray.set([...prevPointData, startTime, endTime, x, y, coord[2] / 1000.0, time, ..._groupColorMap[styleGroupNameArray[i]], startTime, endTime], offset);
-                prevPointData = [x, y, coord[2] / 1000.0, time, ..._groupColorMap[styleGroupNameArray[i]]];
-                offset += 18;
-            }
-        }
-    }
-    return offset;
-}
-/**
- *
- * @param {*} coordinatesArray
- * @returns Float32Array
- * Coordinates array is needed to calculate the size of the buffer.
- */
-function createFloat32Array(coordinatesArray) {
-    let filteredSize = 0;
-    for (let coordinates of coordinatesArray) {
-        filteredSize += coordinates.length * 2 - 2;
-    }
-    const array = new Float32Array(filteredSize * 9);
-    return array;
-}
-export { Adaptor, fillSliceOfFloat32Array, createFloat32Array };