@pirireis/webglobeplugins 0.9.14 → 0.10.0-alpha

package/programs/vectorfields/logics/pixelbased.js

@@ -120,20 +120,11 @@ class Logic {
         return this.gl.getAttribLocation(this.program, 'in_position');
     }
 }
-export default class {
-    constructor(gl) {
-        this.gl = gl;
-        this.logic = glProgramCache.getProgram(gl, Logic);
-    }
-    move(bufferManager, vectorTexture, uboManager) {
-        this.logic.move(bufferManager, vectorTexture, uboManager);
-    }
-    free() {
-        glProgramCache.releaseProgram(this.gl, Logic);
-        this.program = null;
-        this.gl = null;
+export const pixelBasedMoveProgramCache = Object.freeze({
+    getProgram: (gl) => {
+        return glProgramCache.getProgram(gl, Logic);
+    },
+    releaseProgram: (gl) => {
+        glProgramCache.releaseProgram(gl, Logic);
     }
-    getInPositionLocation() {
-        return this.logic.getInPositionLocation();
-    }
-}
+});

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;
+// }

package/util/webglobjectbuilders.js

@@ -241,14 +241,7 @@ export function getColorRamp(colors) {
     canvas.height = 1;
     const gradient = ctx.createLinearGradient(0, 0, 256, 0);
     for (const stop in colors) {
-        // Ensure the stop is a valid number, although `addColorStop` can parse strings,
-        // explicit conversion is safer for object keys if they come from arbitrary sources.
-        const stopValue = parseFloat(stop);
-        if (isNaN(stopValue)) {
-            console.warn(`Invalid stop value for color ramp: ${stop}. Skipping.`);
-            continue;
-        }
-        gradient.addColorStop(stopValue, colors[stop]);
+        gradient.addColorStop(colors[stop][0], colors[stop][1]);
     }
     ctx.fillStyle = gradient;
     ctx.fillRect(0, 0, 256, 1);
@@ -328,18 +321,18 @@ export function getColorRampModed(values, thresholds, mode = "interpolated") {
  * @returns A Uint8Array representing the RGBA pixel data of the default 1x256 color ramp.
  */
 export function defaultColorRamp() {
-    const defaultRampColors = {
-        "0.0": '#5e4fa2',
-        "0.15": '#3288bd',
-        "0.20": '#66c2a5',
-        "0.25": '#66c2a5',
-        "0.3": '#abdda4',
-        "0.4": '#e6f598',
-        "0.5": '#fee08b',
-        "0.6": '#fdae61',
-        "0.7": '#f46d43',
-        "1.0": '#ff1e13'
-    };
+    const defaultRampColors = [
+        [0.0, '#5e4fa2'],
+        [0.15, '#3288bd'],
+        [0.20, '#66c2a5'],
+        [0.25, '#66c2a5'],
+        [0.3, '#abdda4'],
+        [0.4, '#e6f598'],
+        [0.5, '#fee08b'],
+        [0.6, '#fdae61'],
+        [0.7, '#f46d43'],
+        [1.0, '#ff1e13']
+    ];
     return getColorRamp(defaultRampColors);
 }
 /**

package/waveparticles/plugin.js

@@ -1,10 +1,10 @@
 import { GlobeShellWiggle } from "../programs";
 import { defaultblendfunction } from "../util";
-import { vectorfield } from "../programs";
+import { vectorfield } from "../programs/index";
+import { pixelBasedMoveProgramCache } from "../programs/vectorfields/logics/pixelbased";
+import { drawRectangleParticlesProgramCache } from "../programs/vectorfields/logics/drawrectangleparticles";
 import { FadeAway } from "../programs";
-const { PixelBasedMove, DrawRectangleParticles, PingPongBufferManager, WaveParticalUboManager } = vectorfield;
-const MoveParticle = PixelBasedMove;
-const DrawParticle = DrawRectangleParticles;
+const { PingPongBufferManager, WaveParticalUboManager } = vectorfield;
 /**
  * STEPS:
  * 1. move particle | buffers: read b1 write b2 | swap buffers b1 <-> b2
@@ -47,8 +47,8 @@ export default class Plugin {
     init(globe, gl) {
         this.globe = globe;
         this.gl = gl;
-        this.moveParticle = new MoveParticle(gl);
-        this.drawParticle = new DrawParticle(gl);
+        this.moveParticle = pixelBasedMoveProgramCache.getProgram(gl);
+        this.drawParticle = drawRectangleParticlesProgramCache.getProgram(gl);
         this.fadeAway = new FadeAway(gl);
         this.globeShellWiggle = new GlobeShellWiggle(gl, globe, this._globeshellparameters);
         const inPositionLocation = this.moveParticle.getInPositionLocation();
@@ -142,16 +142,21 @@ export default class Plugin {
     }
     // TODO: free all resources
     free() {
-        const { gl, fadeAway, globeShellWiggle, _rgVectorFieldTexture, bufferManager, waveUbo, _drawTextures, _frameBuffer } = this;
+        if (this._isFreed) {
+            console.warn("WaveParticle plugin is already freed");
+            return;
+        }
+        ;
         this._isFreed = true;
+        const { gl, fadeAway, globeShellWiggle, _rgVectorFieldTexture, bufferManager, waveUbo, _drawTextures, _frameBuffer } = this;
         fadeAway.free();
         globeShellWiggle.free();
         gl.deleteTexture(_rgVectorFieldTexture);
         // glProgramCache.releaseProgram(gl, MoveParticle);
-        this.moveParticle.free();
+        pixelBasedMoveProgramCache.getProgram(gl);
         this.moveParticle = null;
         // glProgramCache.releaseProgram(gl, DrawParticle);
-        this.drawParticle.free();
+        drawRectangleParticlesProgramCache.getProgram(gl);
         this.drawParticle = null;
         bufferManager.free();
         waveUbo.free();