@pirireis/webglobeplugins 0.9.15 → 0.10.0-alpha

package/shape-on-terrain/arc/naive/plugin.js

@@ -3,45 +3,46 @@
 // import "../../../programs/interface";
 // import { createBufferAndReadInfo } from '../../../util/gl-util/buffer/attribute-loader';
 // import { populateFloat32Array } from "../../../util/jshelpers/data-filler";
-// import { BufferManagement, BufferManager, BufferOrchestrator } from "../../../util/account/single-attribute-buffer-management/index";
+// import { BufferManagementMap, BufferManager, BufferOrchestrator } from "../../../util/account/single-attribute-buffer-management/index";
 // import { globe3Dcoordinates, globe2Dcoordinates, RADIANS } from "../../../Math/methods";
-// import { Vector3D } from "../../../Math/vector3d";
-// import { Arc } from "../../../Math/arc";
-// import { Plane } from "../../../Math/plane";
+// import { Vec3, Plane, Arc } from "../../../Math/types";
+// import * as vec3 from "../../../Math/vec3";
+// import * as plane from "../../../Math/plane";
+// import * as arc from "../../../Math/arc";
 // import { arcFrustumPlanesIntersection } from "../../../Math/intersections/arc-frustum-planes";
 // import { CameraUniformBlockTotemCache, CameraUniformBlockTotem } from "../../../programs/totems/camerauniformblock";
 // import { FrustumPlanes } from "../../../Math/frustum/types";
 // const VERTEX_COUNT = 360;
 // const INITAL_CAPACITY = 10;
-// const _0vector = new Vector3D();
-// const _0arc = new Arc();
+// const _0vector = [0, 0, 0] as Vec3;
+// const _0arc = arcCreate([1, 0, 0] as Vec3, [0, 1, 0] as Vec3); // zero arc for intersection tests
 // // window add properties
 // declare global {
 //     interface Window {
-//         startPoint: Vector3D;
-//         endPoint: Vector3D;
+//         startPoint: Vec3;
+//         endPoint: Vec3;
 //     }
 // }
 // let interval = 1;
-// const testVec = new Vector3D(0, 0, 1);
-// testVec.setFromLongLat(30 * RADIANS, 30 * RADIANS);
+// const testVec = [0, 0, 0] as Vec3;
+// testVec.fromL(30 * RADIANS, 30 * RADIANS);
 // console.log("testVec", testVec.x, testVec.y, testVec.z);
-// testVec.setFromLongLat(50 * RADIANS, 50 * RADIANS);
+// testVec.fromL(50 * RADIANS, 50 * RADIANS);
 // console.log("testVec", testVec.x, testVec.y, testVec.z);
 // export class NaiveLineOnTerrainPlugin {
 //     public id: string;
-//     private program: ProgramInterface;
-//     private _bufferManagersCompMap: BufferManagement;
-//     private _bufferManagersCompMapTest: BufferManagement;
+//     private program: ProgramInterface | null = null;
+//     private _bufferManagersCompMap: BufferManagementMap | null = null;
+//     private _bufferManagersCompMapTest: BufferManagementMap | null = null;
 //     private _bufferOrchestrator: BufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
 //     private _testOrchestrator: BufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
 //     private _opacity: number = 1;
-//     private _arcUBOHandler: UBOHandler;
-//     private _vao: WebGLVertexArrayObject;
-//     private _vaoAllTest: WebGLVertexArrayObject;
-//     private _ubohandlerAllTest: UBOHandler;
-//     private globe: any;
-//     private gl: WebGL2RenderingContext;
+//     private _arcUBOHandler: UBOHandler | null = null;
+//     private _vao: WebGLVertexArrayObject | null = null;
+//     private _vaoAllTest: WebGLVertexArrayObject | null = null;
+//     private _ubohandlerAllTest: UBOHandler | null = null;
+//     private globe: any | null = null;
+//     private gl: WebGL2RenderingContext | null = null;
 //     private _arcMap: Map<string, Arc>;
 //     private _arcMapTest: Map<string, Arc>;
 //     private _screenPlane: Plane = new Plane();
@@ -161,7 +162,7 @@
 //         // updatePlane
 //         const { globe, _arcMap } = this;
 //         const planes = this._cameraUniformBlock.getFrustumPlanes() as FrustumPlanes;
-// //
+//         //
 //         const cameraPostition = new Vector3D();
 //         cameraPostition.copy(globe.Fp as Vector3D).normalize();
 //         // calculateHorizonPlane(globe, _screenPlane, this.fieldOfView);

package/util/heatwavedatamanager/pointcoordinatesdatacalculator.js

@@ -27,10 +27,10 @@ export default class PointCoordinatesDataCalculator {
         }
         if (!this._isInBBox(long, lat))
             return false;
-        const meta = this._metaCalculater.getFlooredMeta(long, lat);
-        this._pointObjects[key] = pointObject(long, lat, meta.index, callback);
+        const index = this._metaCalculater.getFlooredIndex(long, lat);
+        this._pointObjects[key] = pointObject(long, lat, index, callback);
         if (this._texture0 && this._texture1) {
-            const { data0, data1, interpolated } = this._findAPoint(meta.index);
+            const { data0, data1, interpolated } = this._findAPoint(index);
             callback(data0, data1, interpolated);
         }
         return true;
@@ -51,9 +51,9 @@ export default class PointCoordinatesDataCalculator {
             return false;
         this._pointObjects[key].long = long;
         this._pointObjects[key].lat = lat;
-        const meta = this._metaCalculater.getFlooredMeta(long, lat);
-        this._pointObjects[key].posIndex = meta.index;
-        const { data0, data1, interpolated } = this._findAPoint(meta.index);
+        const index = this._metaCalculater.getFlooredMeta(long, lat);
+        this._pointObjects[key].posIndex = index;
+        const { data0, data1, interpolated } = this._findAPoint(index);
         this._pointObjects[key].callback(data0, data1, interpolated);
         return true;
     }

package/util/heatwavedatamanager/pointcoordsmeta.js

@@ -1,4 +1,9 @@
 export default class PointCoordsMeta {
+    _bbox;
+    _width;
+    _height;
+    _xRatio;
+    _yRatio;
     constructor(bbox, width, height) {
         this._bbox = bbox;
         this._width = width;
@@ -6,12 +11,12 @@ export default class PointCoordsMeta {
         this._xRatio = this._width / (this._bbox[2] - this._bbox[0]);
         this._yRatio = this._height / (this._bbox[3] - this._bbox[1]);
     }
-    getFlooredMeta(long, lat) {
+    getFlooredIndex(long, lat) {
         let x = (long - this._bbox[0]) * this._xRatio;
         let y = (this._bbox[3] - lat) * this._yRatio;
         x = x > 0 ? x - 1 : 0;
         y = y > 0 ? y - 1 : 0;
         const index = Math.floor(y) * this._width + Math.floor(x);
-        return { index };
+        return index;
     }
 }

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

@@ -0,0 +1,160 @@
+import PointCoordsMeta from "./pointcoordsmeta";
+const pointObject = (long, lat, posIndex, callback) => {
+    return { long, lat, posIndex, callback };
+};
+export class TexturePointSampler {
+    _bbox;
+    _width;
+    _height;
+    _textureCount;
+    _metaCalculater;
+    _pointObjects;
+    _textures;
+    _ratio;
+    _isReady = false;
+    constructor(bbox, width, height, textureCount = 2) {
+        this._pointObjects = new Map();
+        this._ratio = 0.0;
+        this._bbox = bbox;
+        this._width = width;
+        this._height = height;
+        this._textureCount = textureCount;
+        this._metaCalculater = new PointCoordsMeta(bbox, width, height);
+        this._textures = new Array(textureCount).fill(null);
+        this._isReady = false;
+    }
+    setTextureCount(textureCount) {
+        if (textureCount !== 1 && textureCount !== 2) {
+            throw new Error("Texture count must be 1 or 2");
+        }
+        this._textureCount = textureCount;
+        this._isReady = false; // Reset readiness when changing texture count
+    }
+    registerPoint(key, long, lat, callback) {
+        if (key in this._pointObjects) {
+            console.warn("key already registered, old one is unregistered");
+            this.unregisterPoint(key);
+        }
+        if (!this._isInBBox(long, lat))
+            return false;
+        const index = this._metaCalculater.getFlooredIndex(long, lat);
+        this._pointObjects.set(key, pointObject(long, lat, index, callback));
+        if (this._isReady) {
+            this._findAndSend(key);
+        }
+        return true;
+    }
+    unregisterPoint(key) {
+        return this._pointObjects.delete(key);
+    }
+    updatePoint(key, long, lat) {
+        const pointObject = this._pointObjects.get(key);
+        if (!pointObject) {
+            console.warn("Point not registered, use registerPoint first");
+            return false;
+        }
+        if (!this._isInBBox(long, lat)) {
+            console.warn("Point is out of bbox, use registerPoint with valid coordinates");
+            pointObject.callback(null, null, null);
+            return false;
+        }
+        ;
+        pointObject.long = long;
+        pointObject.lat = lat;
+        const index = this._metaCalculater.getFlooredIndex(long, lat);
+        pointObject.posIndex = index;
+        this._findAndSend(key);
+        return true;
+    }
+    updateTextureData(ratio, textureData0 = null, textureData1 = null) {
+        if (this._textureCount === 1) {
+            if (textureData0 === null) {
+                this._isReady = false;
+            }
+            else {
+                this._textures[0] = textureData0;
+                this._isReady = true;
+            }
+        }
+        else if (this._textureCount === 2) {
+            if (textureData0 === null || textureData1 === null) {
+                this._isReady = false;
+            }
+            else {
+                this._textures[0] = textureData0;
+                this._textures[1] = textureData1;
+                this._isReady = true;
+            }
+        }
+        else {
+            throw new Error("Invalid texture count, must be 1 or 2");
+        }
+        this.updateRatio(ratio);
+    }
+    updateRatio(ratio) {
+        if (ratio < 0 || ratio > 1) {
+            console.warn("Ratio must be between 0 and 1");
+            ratio = Math.max(0, Math.min(1, ratio)); // Clamp the ratio
+        }
+        this._ratio = ratio;
+        this._pushPointCallbackAll();
+    }
+    flush(callEmptyCallback = false) {
+        if (callEmptyCallback) {
+            for (const [key, { callback }] of this._pointObjects.entries()) {
+                callback(null, null, null);
+            }
+        }
+        this._pointObjects.clear();
+    }
+    // ------- PRIVATE METHODS -------
+    _isInBBox(long, lat) {
+        return lat >= this._bbox[1] && lat <= this._bbox[3] && long >= this._bbox[0] && long <= this._bbox[2];
+    }
+    _findAndSend(key) {
+        const pointObject = this._pointObjects.get(key);
+        if (!pointObject) {
+            console.warn("Point not registered, use registerPoint first");
+            return;
+        }
+        const { posIndex, callback } = pointObject;
+        const data0 = this._textures[0][posIndex];
+        if (this._textureCount === 1) {
+            callback(data0, null, data0);
+        }
+        else if (this._textureCount === 2) {
+            const data1 = this._textures[1][posIndex];
+            const interpolated = data0 * (1 - this._ratio) + data1 * this._ratio;
+            callback(data0, data1, interpolated);
+        }
+    }
+    _pushPointCallbackAll() {
+        if (this._isReady) {
+            for (const key of this._pointObjects.keys()) {
+                this._findAndSend(key);
+            }
+        }
+        else {
+            for (const [key, { callback }] of this._pointObjects.entries()) {
+                callback(null, null, null);
+            }
+        }
+    }
+}
+// function test() {
+//     const cp = window.plugin.getPointCoordinatesDataCalculator();
+//     const bbox = [-15, 25, 70, 60];
+//     cp.registerPoint("left up", -15, 60, (data0, data1, interpolated) => {
+//         console.log("left up", data0, data1, interpolated);
+//     });
+//     cp.registerPoint("right up", 70, 60, (data0, data1, interpolated) => {
+//         console.log("right up", data0, data1, interpolated);
+//     });
+//     cp.registerPoint("left down", -15, 25, (data0, data1, interpolated) => {
+//         console.log("right down", data0, data1, interpolated);
+//     });
+//     cp.registerPoint("right down", 70, 25, (data0, data1, interpolated) => {
+//         console.log("right down", data0, data1, interpolated);
+//     });
+//     return cp;
+// }