@pirireis/webglobeplugins 0.16.0 → 0.16.2

package/util/account/util.js

@@ -1,22 +1,18 @@
-export const vaoAttributeLoader = (gl, buffer, index, size, stride, offset, divisor = null, type = null) => {
-    if (!gl || !buffer) {
-        throw new Error("Invalid WebGL context or buffer");
-    }
-    if (index < 0) {
-        throw new Error("Attribute index must be non-negative");
-    }
-    if (stride < 0 || offset < 0) {
-        throw new Error("Stride and offset must be non-negative");
-    }
-
-    const attribType = type === null ? gl.FLOAT : type;
-    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-    gl.enableVertexAttribArray(index);
-    gl.vertexAttribPointer(index, size, attribType, false, stride, offset);
-    if (divisor !== null) {
-        gl.vertexAttribDivisor(index, divisor);
-    }
-
-}
-
-
+export const vaoAttributeLoader = (gl, buffer, index, size, stride, offset, divisor = null, type = null) => {
+    if (!gl || !buffer) {
+        throw new Error("Invalid WebGL context or buffer");
+    }
+    if (index < 0) {
+        throw new Error("Attribute index must be non-negative");
+    }
+    if (stride < 0 || offset < 0) {
+        throw new Error("Stride and offset must be non-negative");
+    }
+    const attribType = type === null ? gl.FLOAT : type;
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    gl.enableVertexAttribArray(index);
+    gl.vertexAttribPointer(index, size, attribType, false, stride, offset);
+    if (divisor !== null) {
+        gl.vertexAttribDivisor(index, divisor);
+    }
+};

package/util/algorithms/index.js

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

package/util/algorithms/search-binary.js

@@ -1,26 +1,25 @@
-/**
- * @typedef {Array<number>} ListLike
- * @typedef {number || null} Index
- */
-
-/**
- * @param {ListLike} container
- * @param {number} value
- * @returns {Index}
- */
-const findFirstIndexInRange = (container, value) => {
-    let start = 0;
-    let end = container.length - 1;
-    let mid = 0;
-    while (start <= end) {
-        mid = Math.floor((start + end) / 2);
-        if (container[mid] <= value && value <= container[mid + 1]) return mid;
-        if (container[mid] < value) start = mid + 1;
-        else end = mid - 1;
-    }
-    return null;
-}
-
-
-export { findFirstIndexInRange };
-
+/**
+ * @typedef {Array<number>} ListLike
+ * @typedef {number || null} Index
+ */
+/**
+ * @param {ListLike} container
+ * @param {number} value
+ * @returns {Index}
+ */
+const findFirstIndexInRange = (container, value) => {
+    let start = 0;
+    let end = container.length - 1;
+    let mid = 0;
+    while (start <= end) {
+        mid = Math.floor((start + end) / 2);
+        if (container[mid] <= value && value <= container[mid + 1])
+            return mid;
+        if (container[mid] < value)
+            start = mid + 1;
+        else
+            end = mid - 1;
+    }
+    return null;
+};
+export { findFirstIndexInRange };

package/util/check/index.js

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

package/util/geometry/index.js

@@ -0,0 +1,121 @@
+import { GLOBE_DEFAULT_MIN_LOD, GLOBE_DEFAULT_MAX_LOD, POLE2 } from "../../constants";
+function latLongToPixelXY(latitude, longitude) {
+    return {
+        x: (longitude + 180) / 360,
+        y: (90 - latitude) / 180
+    };
+}
+/**
+ * createBBoxMatrix( minX, maxX, minY, maxY)
+ * use this matrix to transform a point from 0 to 1 range to the bounding box
+ * for example: Transform image coordinates to map coordinates
+ * glsl`vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);`
+ */
+function createBBoxMatrix(minX, maxX, minY, maxY) {
+    return new Float32Array([
+        maxX - minX, 0, 0,
+        0, maxY - minY, 0,
+        minX, minY, 1
+    ]);
+}
+function latLongBboxtoPixelXYBbox(minX, minY, maxX, maxY) {
+    const minXY = latLongToPixelXY(minY, minX);
+    const maxXY = latLongToPixelXY(maxY, maxX);
+    return createBBoxMatrix(minXY.x, maxXY.x, minXY.y, maxXY.y);
+}
+/**
+ *
+ * @param array - The array to normalize
+ * @param newLength - The target length for the normalized array
+ * @returns Normalized Float32Array
+ */
+function normalize(array, newLength = 1) {
+    let total = 0;
+    for (let i = 0; i < array.length; i++) {
+        total += array[i] * array[i];
+    }
+    const len = newLength / Math.sqrt(total);
+    const result = new Float32Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        result[i] = array[i] * len;
+    }
+    return result;
+}
+// TODO carry the usefull content to math module. 
+function sphereCoord(long, lat, globe, height = 0) {
+    return normalize(globe.api_GetCartesian3DPoint(long, lat, 0, false), 6378.137 + height);
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function _flatZoomLevel(globe) {
+    const { width, height } = globe.api_GetCurrentWorldWH();
+    const curLod = Math.log(POLE2 / Math.min(width, height)) / Math.LN2 + GLOBE_DEFAULT_MIN_LOD;
+    return curLod;
+}
+function _sphereZoomLevel(globe) {
+    // Sorted array of [lod, altitude]
+    const altitudesAsMeterByLod = [
+        [25, 39.97],
+        [24, 39.97],
+        [23, 39.97],
+        [22, 39.97],
+        [21, 84.84],
+        [20, 169.95],
+        [19, 335.87],
+        [18, 672.80],
+        [17, 1352.01],
+        [16, 2688.90],
+        [15, 5386.31],
+        [14, 10611.02],
+        [13, 21526.80],
+        [12, 43121.77],
+        [11, 86927.14],
+        [10, 171201.96],
+        [9, 336039.90],
+        [8, 678769.05],
+        [7, 1379009.96],
+        [6, 2770920.56],
+        [5, 5837640.93],
+        [4, 12408290.88],
+        [3, 25512546.06],
+        [2, 25512546.06],
+        [1, 25512546.06],
+        [0, 25512546.06]
+    ];
+    const { Distance: altitude } = globe.api_GetCurrentLookInfo();
+    const defMinLod = GLOBE_DEFAULT_MIN_LOD;
+    const defMaxLod = GLOBE_DEFAULT_MAX_LOD;
+    // Binary search for correct LOD
+    let left = 0, right = altitudesAsMeterByLod.length - 1;
+    if (altitude > altitudesAsMeterByLod[right][1]) {
+        return clamp(0, defMinLod, defMaxLod);
+    }
+    if (altitude < altitudesAsMeterByLod[0][1]) {
+        return clamp(25, defMinLod, defMaxLod);
+    }
+    while (left < right) {
+        let mid = Math.floor((left + right) / 2);
+        let currAlt = altitudesAsMeterByLod[mid][1];
+        let nextAlt = altitudesAsMeterByLod[mid + 1][1];
+        if (altitude >= currAlt && altitude <= nextAlt) {
+            let lod = altitudesAsMeterByLod[mid][0];
+            if (currAlt === nextAlt) {
+                return clamp(lod, defMinLod, defMaxLod);
+            }
+            return clamp(lod + (-currAlt + altitude) / (-currAlt + nextAlt), defMinLod, defMaxLod);
+        }
+        if (altitude > nextAlt) {
+            left = mid + 1;
+        }
+        else {
+            right = mid;
+        }
+    }
+    return GLOBE_DEFAULT_MIN_LOD;
+}
+function approximatedZoomLevel(globe) {
+    const is3D = globe.api_GetCurrentGeometry() === 0;
+    return is3D ? _sphereZoomLevel(globe) : _flatZoomLevel(globe);
+}
+export { createBBoxMatrix, latLongToPixelXY, latLongBboxtoPixelXYBbox, sphereCoord, normalize, approximatedZoomLevel };

package/util/gl-util/uniform-block/shader.js

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

package/util/heatwavedatamanager/datamanager.js

@@ -1,168 +1,149 @@
-/**
- * todo: 
- * data must be processed before being set to the cache
- */
-
-export default class DataManager {
-    /**
-     * 
-     * @param {Array<number>} timeEpocs | array of time epocs
-     * @param {Function} fetchMethod | fetchMethod(time) => Promise<data> 
-     * @param {boolean} autoDownload | auto download data or not
-    */
-    constructor(timeEpocs, fetchMethod, { autoDownload = true } = {}) {
-
-        this._timeEpocs = timeEpocs.sort((a, b) => a - b);
-        this._datas = []; this._datas.length = timeEpocs.length;
-
-        // in construction
-        this._dataPromises = []; this._dataPromises.length = timeEpocs.length;
-
-        this._fetchMethod = fetchMethod;
-        this._callbackmethods = [];
-        this._callbackmethodOwners = [];
-        this._lastTime = -1;
-        this._lastIndex = -1;
-        this.autoDownload(autoDownload);
-    }
-
-
-    autoDownload(bool, time) {
-        if (!bool) {
-            this._autoDownload = false;
-            return;
-        }
-        let index = this._lastIndex === -1 ? 0 : this._lastIndex;
-        if (time !== undefined) {
-            if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
-                this._autoDownload = bool;
-                return;
-            }
-            index = this._findIndex(time);
-        }
-
-        if (this._downloadStartIndex === index && this._autoDownload === bool) return;
-        this._downloadStartIndex = index;
-        this._autoDownload = bool;
-        const recursion = (startId, currentDownloadId) => {
-            if (startId !== this._downloadStartIndex) return;
-            if (currentDownloadId < this._timeEpocs.length && this._autoDownload) {
-                this._getData(currentDownloadId).then(() => {
-                    recursion(startId, currentDownloadId + 1);
-                });
-            }
-        }
-        recursion(index, index);
-        // save index as start index
-        //start recursive download
-
-        // use started id as a flag to stop the download
-    }
-
-
-
-    /**
-     * @param {number} time 
-     * It looks like async function is not needed here. changes just overwrites the previous changes.
-     */
-    updateTime(time) {
-        if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
-            this._dontRender();
-            return;
-        }
-        this._lastTime = time;
-        const index = this._findIndex(time);
-        const ratio = this._getRatio(time, index);
-        Promise.all([this._getData(index - 1), this._getData(index)]).then((datas) => {
-            if (this._lastTime === time) {
-                this._lastIndex = index;
-                this._ratio = ratio;
-                this._pushCallback(ratio, datas);
-            }
-        });
-    }
-
-
-    register(key, callback) {
-        if (this._callbackmethodOwners.indexOf(key) !== -1) {
-            console.warn("key already registered, old one is unregistered");
-            this.unregister(key);
-        }
-        this._callbackmethods.push(callback);
-        this._callbackmethodOwners.push(key);
-        if (this._lastIndex !== -1) callback(this._ratio, this._datas[this._lastIndex - 1], this._datas[this._lastIndex]);
-    }
-
-
-    /**
-     * @param {*} key | id of the owner of the callback
-     */
-    unregister(key) {
-        let index = this._callbackmethodOwners.indexOf(key);
-        if (index !== -1) {
-            this._callbackmethods.splice(index, 1);
-            this._callbackmethodOwners.splice(index, 1);
-        }
-        if (this._callbackmethods.length === 0) {
-            this.free();
-        }
-    }
-
-
-    free() {
-        this._callbackmethods = [];
-        this._callbackmethodOwners = [];
-        this._autoDownload = false;
-    }
-
-    _findIndex(time) {
-        const { _timeEpocs } = this;
-        let index = this._lastIndex === -1 ? 1 : this._lastIndex;
-        if (this)
-            if (time < _timeEpocs[index - 1]) {
-                while (index > 1 && time < _timeEpocs[index - 1]) {
-                    index--;
-                }
-            } else if (time > _timeEpocs[index]) {
-                while (index < _timeEpocs.length - 1 && time > _timeEpocs[index]) {
-                    index++;
-                }
-            }
-        return index;
-    }
-
-
-    _getRatio(time, index) {
-        return (time - this._timeEpocs[index - 1]) / (this._timeEpocs[index] - this._timeEpocs[index - 1]);
-    }
-
-
-    _pushCallback(ratio, datas) {
-        for (let i = 0; i < this._callbackmethods.length; i++) {
-            this._callbackmethods[i](ratio, ...datas);
-        }
-    }
-
-
-    async _getData(index) {
-        if (index < 0 || index >= this._timeEpocs.length) {
-            throw new Error("Index out of range");
-        }
-        if (!this._datas[index]) {
-            if (!this._dataPromises[index]) this._dataPromises[index] = this._fetchMethod(this._timeEpocs[index]).then((data) => {
-                this._datas[index] = data;
-            }, (error) => {
-                console.error("error", error);
-            }).finally(() => {
-                this._dataPromises[index] = null;
-            });
-        }
-        await this._dataPromises[index];
-        return this._datas[index];
-    }
-
-    _dontRender() {
-        this._pushCallback(0, [null, null]);
-    }
-
-}
+/**
+ * todo:
+ * data must be processed before being set to the cache
+ */
+export default class DataManager {
+    /**
+     *
+     * @param {Array<number>} timeEpocs | array of time epocs
+     * @param {Function} fetchMethod | fetchMethod(time) => Promise<data>
+     * @param {boolean} autoDownload | auto download data or not
+    */
+    constructor(timeEpocs, fetchMethod, { autoDownload = true } = {}) {
+        this._timeEpocs = timeEpocs.sort((a, b) => a - b);
+        this._datas = [];
+        this._datas.length = timeEpocs.length;
+        // in construction
+        this._dataPromises = [];
+        this._dataPromises.length = timeEpocs.length;
+        this._fetchMethod = fetchMethod;
+        this._callbackmethods = [];
+        this._callbackmethodOwners = [];
+        this._lastTime = -1;
+        this._lastIndex = -1;
+        this.autoDownload(autoDownload);
+    }
+    autoDownload(bool, time) {
+        if (!bool) {
+            this._autoDownload = false;
+            return;
+        }
+        let index = this._lastIndex === -1 ? 0 : this._lastIndex;
+        if (time !== undefined) {
+            if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
+                this._autoDownload = bool;
+                return;
+            }
+            index = this._findIndex(time);
+        }
+        if (this._downloadStartIndex === index && this._autoDownload === bool)
+            return;
+        this._downloadStartIndex = index;
+        this._autoDownload = bool;
+        const recursion = (startId, currentDownloadId) => {
+            if (startId !== this._downloadStartIndex)
+                return;
+            if (currentDownloadId < this._timeEpocs.length && this._autoDownload) {
+                this._getData(currentDownloadId).then(() => {
+                    recursion(startId, currentDownloadId + 1);
+                });
+            }
+        };
+        recursion(index, index);
+        // save index as start index
+        //start recursive download
+        // use started id as a flag to stop the download
+    }
+    /**
+     * @param {number} time
+     * It looks like async function is not needed here. changes just overwrites the previous changes.
+     */
+    updateTime(time) {
+        if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
+            this._dontRender();
+            return;
+        }
+        this._lastTime = time;
+        const index = this._findIndex(time);
+        const ratio = this._getRatio(time, index);
+        Promise.all([this._getData(index - 1), this._getData(index)]).then((datas) => {
+            if (this._lastTime === time) {
+                this._lastIndex = index;
+                this._ratio = ratio;
+                this._pushCallback(ratio, datas);
+            }
+        });
+    }
+    register(key, callback) {
+        if (this._callbackmethodOwners.indexOf(key) !== -1) {
+            console.warn("key already registered, old one is unregistered");
+            this.unregister(key);
+        }
+        this._callbackmethods.push(callback);
+        this._callbackmethodOwners.push(key);
+        if (this._lastIndex !== -1)
+            callback(this._ratio, this._datas[this._lastIndex - 1], this._datas[this._lastIndex]);
+    }
+    /**
+     * @param {*} key | id of the owner of the callback
+     */
+    unregister(key) {
+        let index = this._callbackmethodOwners.indexOf(key);
+        if (index !== -1) {
+            this._callbackmethods.splice(index, 1);
+            this._callbackmethodOwners.splice(index, 1);
+        }
+        if (this._callbackmethods.length === 0) {
+            this.free();
+        }
+    }
+    free() {
+        this._callbackmethods = [];
+        this._callbackmethodOwners = [];
+        this._autoDownload = false;
+    }
+    _findIndex(time) {
+        const { _timeEpocs } = this;
+        let index = this._lastIndex === -1 ? 1 : this._lastIndex;
+        if (this)
+            if (time < _timeEpocs[index - 1]) {
+                while (index > 1 && time < _timeEpocs[index - 1]) {
+                    index--;
+                }
+            }
+            else if (time > _timeEpocs[index]) {
+                while (index < _timeEpocs.length - 1 && time > _timeEpocs[index]) {
+                    index++;
+                }
+            }
+        return index;
+    }
+    _getRatio(time, index) {
+        return (time - this._timeEpocs[index - 1]) / (this._timeEpocs[index] - this._timeEpocs[index - 1]);
+    }
+    _pushCallback(ratio, datas) {
+        for (let i = 0; i < this._callbackmethods.length; i++) {
+            this._callbackmethods[i](ratio, ...datas);
+        }
+    }
+    async _getData(index) {
+        if (index < 0 || index >= this._timeEpocs.length) {
+            throw new Error("Index out of range");
+        }
+        if (!this._datas[index]) {
+            if (!this._dataPromises[index])
+                this._dataPromises[index] = this._fetchMethod(this._timeEpocs[index]).then((data) => {
+                    this._datas[index] = data;
+                }, (error) => {
+                    console.error("error", error);
+                }).finally(() => {
+                    this._dataPromises[index] = null;
+                });
+        }
+        await this._dataPromises[index];
+        return this._datas[index];
+    }
+    _dontRender() {
+        this._pushCallback(0, [null, null]);
+    }
+}

package/util/heatwavedatamanager/index.js

@@ -1,2 +1,2 @@
-import HeatWaveDataManager from "./datamanager";
-export { HeatWaveDataManager };
+import HeatWaveDataManager from "./datamanager";
+export { HeatWaveDataManager };

package/util/index.js

@@ -1,13 +1,13 @@
-import * as webglobjectbuilders from './webglobjectbuilders';
-import * as shaderfunctions from './shaderfunctions';
-import * as geometry from './geometry';
-import * as webglobe from './webglobe';
-import * as programs from './programs';
-import * as heatwavedatamanager from './heatwavedatamanager';
-export { webglobjectbuilders, shaderfunctions, geometry, webglobe, programs, heatwavedatamanager };
-export * from './webglobe';
-export * from './webglobjectbuilders';
-export * from './shaderfunctions';
-export * from './geometry';
-export * from './programs';
-export * from './heatwavedatamanager';
+import * as webglobjectbuilders from './webglobjectbuilders';
+import * as shaderfunctions from './shaderfunctions';
+import * as geometry from './geometry';
+import * as webglobe from './webglobe';
+import * as programs from './programs';
+import * as heatwavedatamanager from './heatwavedatamanager';
+export { webglobjectbuilders, shaderfunctions, geometry, webglobe, programs, heatwavedatamanager };
+export * from './webglobe';
+export * from './webglobjectbuilders';
+export * from './shaderfunctions';
+export * from './geometry';
+export * from './programs';
+export * from './heatwavedatamanager';

package/util/interpolation/index.js

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

package/util/interpolation/timetrack/index.js

@@ -1,9 +1,2 @@
-const createWorker = () =>  new Worker(
-            new URL(
-                './web-worker.js',
-                import.meta.url
-            ), { type: 'module' }
-        );
-
-
-export {createWorker}
+const createWorker = () => new Worker(new URL('./web-worker.js', import.meta.url), { type: 'module' });
+export { createWorker };