@pirireis/webglobeplugins 0.9.1 → 0.9.3

package/util/heatwavedatamanager/pointcoordinatesdatacalculator.js

@@ -114,20 +114,20 @@ export default class PointCoordinatesDataCalculator {
     }
 }
 
-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;
-}
+// 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/waveparticles/plugin.js

@@ -48,6 +48,7 @@ export default class Plugin {
         }
         this._stepIndex = 0;
         this._fullCycleStepCount = 3;
+        this._isFreed = false;
     }
 
     init(globe, gl) {
@@ -96,6 +97,7 @@ export default class Plugin {
     }
 
     draw3D() {
+        if (this._isFreed) return;
         const { gl, moveParticle, drawParticle, bufferManager, globeShellWiggle, waveUbo, fadeAway, _rgVectorFieldTexture } = this;
 
         gl.disable(gl.DEPTH_TEST);
@@ -168,6 +170,7 @@ export default class Plugin {
     // TODO: free all resources
     free() {
         const { gl, fadeAway, globeShellWiggle, _rgVectorFieldTexture, bufferManager, waveUbo, _drawTextures, _frameBuffer } = this;
+        this._isFreed = true;
         fadeAway.free();
         globeShellWiggle.free();
         gl.deleteTexture(_rgVectorFieldTexture);

package/wind/plugin.js

@@ -300,18 +300,6 @@ void main() {
 }`;
 
 
-const reverseDefaultRampColors = [
-    [0.0, '#d53e4f'],
-    [0.2, '#f46d43'],
-    [0.3, '#fdae61'],
-    [0.4, '#fee08b'],
-    [0.5, '#e6f598'],
-    [0.6, '#abdda4'],
-    [0.7, '#66c2a5'],
-    [0.9, '#3288bd'],
-    // 1.0 deep purple
-    [1.0, '#5e4fa2']
-];
 
 const defaultRampColors = [
     [0.0, '#5e4fa2'],
@@ -492,7 +480,6 @@ export default class WindPlugin {
     }
 
     setColorRampDefault() {
-        const { gl } = this;
         const { uMax, uMin, vMax, vMin } = this.windData;
         const maxSpeed = Math.sqrt(
             uMax * uMax + vMax * vMax
@@ -516,11 +503,11 @@ export default class WindPlugin {
      */
     setLegend(legendData) {
         const { gl } = this;
-        if (gl == null) {
+        if (gl === null) {
             throw new Error("wind plugin. setColorRampFromService is called before plugin is registered.");
         }
         const { thresholds, values } = legendData;
-        if (thresholds.length == 0 || values.length == 0) {
+        if (thresholds.length === 0 || values.length === 0) {
             return;
         }
         thresholds.push(thresholds[thresholds.length - 1]);
@@ -591,7 +578,7 @@ export default class WindPlugin {
      * @param {number} windData.vMax - maximum v value
      */
     setWind(windData) {
-        if (windData == null) {
+        if (windData === null) {
             return;
         }
         const windDataMeta = this._windDataMeta;
@@ -693,10 +680,10 @@ export default class WindPlugin {
 
     _doDraw() {
         const globe = this.globe;
-        if (this.windData == null) {
+        if (this.windData === null) {
             return false;
         }
-        if (globe.api_IsScreenMoving() || this._lastLOD != globe.api_GetCurrentLODWithDecimal()) {
+        if (globe.api_IsScreenMoving() || this._lastLOD !== globe.api_GetCurrentLODWithDecimal()) {
             if (!this._screenMoved) {
                 this._screenMoved = true;
             }
@@ -850,7 +837,7 @@ export default class WindPlugin {
     // globe calls `setGeometry` method on map projection change. FLAT or SPHERE
 
     setGeometry() {
-        if (this.windData == null) {
+        if (this.windData === null) {
             return;
         }
         const { globe, gl } = this;

package/Math/methodology/arc-part-on-screen.ts

@@ -1,47 +0,0 @@
-import { Plane } from "../plane";
-import { Vector3D } from "../vector3d";
-import { Arc } from "../arc";
-
-
-
-const Radians = Math.PI / 180;
-
-export class ArcPartOnScreen {
-    private _oldLookInfo: { CenterLong: number, CenterLat: number, Distance: number, Tilt: number, NorthAng: number };
-    private _boundPlane: Plane;
-
-    constructor() {
-        this._boundPlane = new Plane(new Vector3D(0, 0, 0), 0);
-        this._oldLookInfo = { CenterLong: 0, CenterLat: -190, Distance: 0, Tilt: 0, NorthAng: 0 };
-    }
-
-
-    updateBoundPlane(lookInfo): boolean {
-        if (this._oldLookInfo && this._oldLookInfo.CenterLong === lookInfo.CenterLong && this._oldLookInfo.CenterLat === lookInfo.CenterLat) {
-            return false;
-        }
-        /**
-         * lookInfo {CenterLong: 47.75355881750585, CenterLat: 42.3417076206803, Distance: 2286603.4020860917, Tilt: 0.05, NorthAng: -13.829359965098265}
-         */
-        this._oldLookInfo.CenterLong = lookInfo.CenterLong;
-        this._oldLookInfo.CenterLat = lookInfo.CenterLat;
-        this._oldLookInfo.Distance = lookInfo.Distance;
-        this._oldLookInfo.Tilt = lookInfo.Tilt;
-        this._oldLookInfo.NorthAng = lookInfo.NorthAng;
-
-        Plane.fromGlobeLookInfo(Radians * lookInfo.CenterLong, Radians * lookInfo.CenterLat, lookInfo.Distance, this._boundPlane);
-        return true;
-    }
-
-
-
-    getArcPartOnScreen(arc: Arc, target: Arc): boolean {
-        // _imaginaryPlane.set(arc.greatCirclePlaneNormalVector, arc.pointA.dot(arc.greatCirclePlaneNormalVector));
-        // const intersection = _imaginaryPlane.intersectionPlane(this._boundPlane);
-        // if (!(intersection instanceof Ray)) return false;
-        // _ray.copy(intersection as Ray);
-        // const [point1, point2] = _ray.intersectionSphere(_unitShphereCenter, _unitShphereRadius) as [Vector3D, Vector3D];
-        const result = arc.intersectionMedium(this._boundPlane, target);
-        return !(result === null);
-    }
-}

package/Math/ray.ts

@@ -1,101 +0,0 @@
-import { Vector3D } from './vector3d';
-import { Plane } from './plane';
-
-
-const _0vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
-const _1vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
-const _3vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
-export class Ray {
-
-    origin: Vector3D;
-    direction: Vector3D;
-
-    constructor(origin: Vector3D, direction: Vector3D) {
-        this.origin = origin;
-        this.direction = direction.normalize();
-    }
-
-    copy(ray: Ray): Ray {
-        this.origin.copy(ray.origin);
-        this.direction.copy(ray.direction);
-        return this;
-    }
-
-    clone(): Ray {
-        return new Ray(this.origin.clone(), this.direction.clone());
-    }
-
-
-    at(distance: number, out: Vector3D): Vector3D {
-        return out.copy(this.direction).multiplyByScaler(distance).add(this.origin);
-    }
-
-
-    set(origin: Vector3D, direction: Vector3D): Ray {
-        this.origin.copy(origin);
-        this.direction.copy(direction).normalize();
-        return this;
-    }
-
-    intersectionSphere(sphereOrigin: Vector3D, sphereRadius: number): [Vector3D, Vector3D] | null {
-
-        const l = this.direction.clone().normalize();
-        const s = this.origin.clone().subtract(sphereOrigin);
-        const b = l.dot(s);
-
-        const c = s.dot(s) - sphereRadius * sphereRadius;
-        const d = b * b - c;
-
-        if (d < 0) {
-            return null; // no intersection
-        } else {
-            const x = Math.sqrt(d);
-            const t1 = -b - x;
-            const t2 = -b + x;
-            // l and s are used as output vectors
-            return [this.at(t1, l), this.at(t2, s)];
-        }
-    }
-
-
-    contains(point: Vector3D): boolean {
-        const x = this.origin.x - point.x;
-        const y = this.origin.y - point.y;
-        const z = this.origin.z - point.z;
-        const distance = Math.sqrt(x * x + y * y + z * z);
-        if (distance < 0.0001) {
-            return true; // point is very close to the origin
-        }
-        return Math.abs(_0vector.set(x / distance, y / distance, z / distance).dot(this.direction)) > 0.9999; // point direction  towards origin 
-        // is very close to the ray direction
-    }
-
-    // TODO: Applay this approach to other static methods on other Math classes.
-    static fromTwoPlanes(planeA: Plane, planeB: Plane, target: Ray | null = null): Ray | null {
-        const intersection = planeA.intersectionPlane(planeB);
-        if (intersection === null || intersection instanceof Plane) {
-            return null; // planes are parallel
-        }
-        if (target === null) {
-            target = new Ray(intersection.origin, intersection.direction);
-        }
-        else {
-            target.set(intersection.origin, intersection.direction);
-        }
-        return target;
-    }
-
-
-    static fromTwoPoints(pointA: Vector3D, pointB: Vector3D, target: Ray | null = null): Ray {
-        if (target === null) {
-            target = new Ray(pointA, pointB.clone().subtract(pointA).normalize());
-        } else {
-            target.set(pointA, pointB.clone().subtract(pointA).normalize());
-        }
-        return target;
-    }
-
-}
-
-
-

package/Math/vector3d.ts

@@ -1,241 +0,0 @@
-import { Vector3D as IVector3D, Radians } from "./types";
-import { Quaternion } from "./quaternion";
-
-
-
-export class Vector3D implements IVector3D {
-    x: number;
-    y: number;
-    z: number;
-
-
-    constructor(x: number = 0, y: number = 0, z: number = 0) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-
-
-
-    normalize(): Vector3D {
-        this.divideByScaler(this.length() || 1);
-        return this;
-    }
-
-
-
-    dot(other: Vector3D) {
-        return this.x * other.x + this.y * other.y + this.z * other.z;
-    }
-
-
-
-    equals(other: Vector3D, epsilon: number = 0.0000001): boolean {
-        // TODO: consider coppying other in case is true to avoid difference accumulation. 
-        return Math.abs(this.x - other.x) < epsilon &&
-            Math.abs(this.y - other.y) < epsilon &&
-            Math.abs(this.z - other.z) < epsilon;
-    }
-
-
-
-
-    static crossVectors(a: Vector3D, b: Vector3D, c: Vector3D = new Vector3D): Vector3D {
-        const x = a.y * b.z - a.z * b.y;
-        const y = a.z * b.x - a.x * b.z;
-        const z = a.x * b.y - a.y * b.x;
-
-        c.set(x, y, z);
-
-        return c;
-    }
-
-
-
-    cross(other: Vector3D): Vector3D {
-        return Vector3D.crossVectors(this, other, this);
-    }
-
-
-
-    angle(other: Vector3D): number {
-        const a = this.length();
-        const b = other.length();
-        const c = this.dot(other);
-        const angle = Math.acos(c / (a * b));
-
-        return isNaN(angle) ? 0 : angle;
-    }
-
-    lerpVectors(a: Vector3D, b: Vector3D, t: number): Vector3D {
-        this.x = a.x + (b.x - a.x) * t;
-        this.y = a.y + (b.y - a.y) * t;
-        this.z = a.z + (b.z - a.z) * t;
-
-        return this;
-    }
-
-
-
-    lerp(other: Vector3D, t: number): Vector3D {
-        return this.lerpVectors(this, other, t);
-    }
-
-
-
-    scale(scalar: number): Vector3D {
-        this.x *= scalar;
-        this.y *= scalar;
-        this.z *= scalar;
-
-        return this;
-    }
-
-    dotProduct(other: Vector3D): number {
-        return this.x * other.x + this.y * other.y + this.z * other.z;
-    }
-
-
-    dotDivide(other: Vector3D): number {
-        return this.x / other.x + this.y / other.y + this.z / other.z;
-    }
-
-
-    add(other: Vector3D): Vector3D {
-        this.x += other.x;
-        this.y += other.y;
-        this.z += other.z;
-
-        return this;
-    }
-
-
-
-    negate(): Vector3D {
-        this.x = -this.x;
-        this.y = -this.y;
-        this.z = -this.z;
-
-        return this;
-    }
-
-
-
-    length(): number {
-        return Math.sqrt(this.x ** 2 + this.y ** 2 + this.z ** 2);
-    }
-
-
-
-    subtract(other: Vector3D): Vector3D {
-        this.x -= other.x;
-        this.y -= other.y;
-        this.z -= other.z;
-
-        return this;
-    }
-
-
-
-    applyQuaternion(q: Quaternion): Vector3D {
-        const x = this.x, y = this.y, z = this.z;
-        const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
-        // calculate quat * vector
-        const ix = qw * x + qy * z - qz * y;
-        const iy = qw * y + qz * x - qx * z;
-        const iz = qw * z + qx * y - qy * x;
-        const iw = -qx * x - qy * y - qz * z;
-        // calculate result * inverse quat
-        this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
-        this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
-        this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
-        return this;
-    }
-
-
-
-    multiplyByScaler(scalar: number): Vector3D {
-        this.x *= scalar;
-        this.y *= scalar;
-        this.z *= scalar;
-
-        return this;
-    };
-
-
-
-    divideByScaler(scalar: number): Vector3D {
-        this.x /= scalar;
-        this.y /= scalar;
-        this.z /= scalar;
-
-        return this;
-    }
-
-
-
-    copy(other: Vector3D): Vector3D {
-        this.x = other.x;
-        this.y = other.y;
-        this.z = other.z;
-
-        return this
-    }
-
-
-
-    set(x: number, y: number, z: number): Vector3D {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-
-        return this
-    }
-
-
-
-    clone(): Vector3D {
-        return new Vector3D(this.x, this.y, this.z);
-    }
-
-
-
-    randomUnit(): Vector3D {
-        const x = Math.random() * 2 - 1;
-        const y = Math.random() * 2 - 1;
-        const z = Math.random() * 2 - 1;
-
-        return this.set(x, y, z).normalize();
-    }
-
-
-
-    setFromLonLat(lon: Radians, lat: Radians): Vector3D {
-        const x = Math.cos(lat) * Math.cos(lon);
-        const y = Math.cos(lat) * Math.sin(lon);
-        const z = Math.sin(lat);
-
-        return this.set(x, y, z);
-    }
-
-
-
-
-    toLonLat(): { lon: Radians, lat: Radians } {
-        const len = this.length();
-        const x = this.x / len;
-        const y = this.y / len;
-        const z = this.z / len;
-        const lon = Math.atan2(y, x);
-        const lat = Math.asin(z);
-
-        return { lon, lat };
-    }
-
-
-
-    static fromLonLatRadians(lon: Radians, lat: Radians): Vector3D {
-        return new Vector3D().setFromLonLat(lon, lat);
-    }
-
-}

package/tests/Math/arc.test.ts

@@ -1,112 +0,0 @@
-import { Arc } from '../../Math/arc';
-import { Vector3D } from '../../Math/vector3d';
-import { Quaternion } from '../../Math/quaternion';
-import { Plane } from '../../Math/plane';
-
-let _0vector: Vector3D;
-let _1vector: Vector3D;
-let _0arc: Arc;
-let _1arc: Arc;
-let _0quaternion: Quaternion;
-let _medium: Plane;
-
-beforeAll(() => {
-
-    _0vector = new Vector3D(0, 0, 0);
-    _1vector = new Vector3D(1, 1, 1).normalize();
-    _0arc = new Arc(_0vector, _1vector);
-    _1arc = new Arc(_0vector, _1vector);
-    _0quaternion = new Quaternion(0, 0, 0, 1);
-    _medium = new Plane(new Vector3D(0, 0, 1), 0);
-
-});
-
-
-
-test("intersectionMedium", () => {
-
-
-    _0quaternion.setFromAxisAngle(_0vector.set(1, 0, 0), -Math.PI / 3);
-    const A = _0vector.set(0, 1, 0).applyQuaternion(_0quaternion).clone();
-    _0quaternion.setFromAxisAngle(_0vector.set(1, 0, 0), Math.PI / 3);
-    const B = _0vector.set(0, 1, 0).applyQuaternion(_0quaternion).clone();
-    _0arc.setFromUnitVectors(A, B);
-    const _1arc = _0arc.intersectionMedium(_medium)!;
-
-    expect(_1arc !== null).toBeTruthy();
-    expect([A, B].some((v) => v.equals(_1arc.pointA) || v.equals(_1arc.pointB))).toBeTruthy();
-    expect([_1arc.pointA, _1arc.pointB].some((v) => v.equals(new Vector3D(0, 1, 0)))).toBeTruthy();
-
-});
-
-
-test("intersectionMedium 2 - single point arc", () => {
-    _0arc.setFromUnitVectors(new Vector3D(0, 1, 0), new Vector3D(0, 1, 0));
-    const result = _0arc.intersectionMedium(_medium);
-    expect(result).toBeNull();
-});
-
-
-describe(`intersectionMedium 3 - return full arc`, () => {
-    let i = 0;
-    test(`intersectionMedium 3 - return full arc  ${i} `, () => {
-        for (let i = 0; i < 100; i++) {
-            _medium.set(new Vector3D(0, 0, 1), 0);
-            _0vector.randomUnit();
-            _0vector.z = Math.abs(_0vector.z); // make sure point is above the plane
-            _1vector.randomUnit();
-            _1vector.z = Math.abs(_1vector.z); // make sure point is above the plane
-            expect(Math.abs(_0vector.length() - 1) < 0.0001).toBeTruthy();
-            expect(Math.abs(_1vector.length() - 1) < 0.0001).toBeTruthy();
-            _0arc.setFromUnitVectors(_0vector, _1vector);
-
-            const _1arc = _0arc.intersectionMedium(_medium)!;
-            // if (_1arc === null) {
-            //     console.log(_0arc, _medium);
-            // }
-            expect(_1arc !== null).toBeTruthy();
-            expect(_0arc.equals(_1arc)).toBeTruthy();
-        }
-    });
-});
-
-
-describe(`intersectionMedium 4 - return half arc`, () => {
-    let i = 0;
-    test(`intersectionMedium 4 - return half arc  ${i} `, () => {
-        for (let i = 0; i < 100; i++) {
-            _medium.set(new Vector3D(0, 0, 1), 0);
-
-            _0vector.randomUnit();
-            _1vector.copy(_0vector);
-            _1vector.z *= -1;
-
-            expect(Math.abs(_0vector.length() - 1) < 0.0001).toBeTruthy();
-            expect(Math.abs(_1vector.length() - 1) < 0.0001).toBeTruthy();
-            _0arc.setFromUnitVectors(_0vector, _1vector);
-
-            const _1arc = _0arc.intersectionMedium(_medium)!;
-            // if (_1arc === null) {
-            //     console.log(_0arc, _medium);
-            // }
-            expect(_1arc !== null).toBeTruthy();
-
-            expect([_1arc.pointA.z, _1arc.pointB.z].some((v) => v === 0)).toBeTruthy();
-
-            // expect(_0arc.equals(_1arc)).toBeTruthy();
-        }
-    });
-});
-
-
-
-test("populatePoints3D 1", () => {
-    _0arc.setFromUnitVectors(new Vector3D(0, 1, 0), new Vector3D(0, 1, 0));
-    const result = _0arc.populatePoints3D(10);
-    expect(result.length).toBe(10 * 3);
-    _0vector.set(result[0], result[1], result[2]);
-    expect(_0vector.equals(_0arc.pointA)).toBeTruthy();
-    _0vector.set(result[27 + 0], result[27 + 1], result[27 + 2]);
-    expect(_0vector.equals(_0arc.pointB)).toBeTruthy();
-});
-