@pirireis/webglobeplugins 0.9.14 → 0.10.0-alpha

package/Math/plane.js

@@ -1,57 +1,56 @@
 import { EPSILON } from "./constants";
-import { vec3 } from "./vec3";
-const _0vector = /*@__PURE__*/ vec3.create(0, 0, 0);
-const _1vector = /*@__PURE__*/ vec3.create(1, 1, 1);
-export const plane = Object.freeze({
-    create(normal = vec3.create(), distance = 0) {
-        return {
-            normal: vec3.clone(normal),
-            distance: distance
-        };
-    },
-    set(out, normal, distance) {
-        vec3.copy(out.normal, normal);
-        out.distance = distance;
-        return out;
-    },
-    fromValues(out, nx, ny, nz, distance) {
-        vec3.set(out.normal, nx, ny, nz);
-        out.distance = distance;
-    },
-    copy(out, a) {
-        vec3.copy(out.normal, a.normal);
-        out.distance = a.distance;
-        return out;
-    },
-    clone(a) {
-        return {
-            normal: vec3.clone(a.normal),
-            distance: a.distance
-        };
-    },
-    distanceToPoint(plane, point) {
-        return vec3.dot(plane.normal, point) - plane.distance;
-    },
-    projectPoint(out, plane, point) {
-        const distance = this.distanceToPoint(plane, point);
-        vec3.multiplyScalar(out, plane.normal, distance);
-        vec3.subtract(out, point, out);
-    },
-    equals(plane, other) {
-        return vec3.equals(plane.normal, other.normal) && Math.abs(plane.distance - other.distance) < EPSILON;
-    },
-    fromNormalAndCoplanarPoint(out, normal, point) {
-        vec3.copy(out.normal, normal);
-        out.distance = vec3.dot(point, normal);
-    },
-    fromPoints(out, a, b, c) {
-        vec3.subtract(_0vector, b, a);
-        vec3.subtract(_1vector, c, a);
-        vec3.cross(out.normal, _0vector, _1vector);
-        vec3.normalize(out.normal, out.normal);
-        out.distance = vec3.dot(out.normal, a);
-    },
-    getUnitSphereRadiusAngle(plane) {
-        return Math.acos(Math.max(Math.min(plane.distance, 1), -1));
-    }
-});
+import { copy as vec3copy, create as vec3create, clone as vec3clone, set as vec3set, dot, subtract, multiplyScalar, cross, normalize, equals as vec3equals } from "./vec3";
+const _0vector = /*@__PURE__*/ vec3create(0, 0, 0);
+const _1vector = /*@__PURE__*/ vec3create(1, 1, 1);
+function create(normal = vec3create(), distance = 0) {
+    return {
+        normal: vec3clone(normal),
+        distance: distance
+    };
+}
+function set(out, normal, distance) {
+    vec3copy(out.normal, normal);
+    out.distance = distance;
+    return out;
+}
+function fromValues(out, nx, ny, nz, distance) {
+    vec3set(out.normal, nx, ny, nz);
+    out.distance = distance;
+}
+function copy(out, a) {
+    vec3copy(out.normal, a.normal);
+    out.distance = a.distance;
+    return out;
+}
+function clone(a) {
+    return {
+        normal: vec3clone(a.normal),
+        distance: a.distance
+    };
+}
+function distanceToPoint(plane, point) {
+    return dot(plane.normal, point) - plane.distance;
+}
+function projectPoint(out, plane, point) {
+    const distance = distanceToPoint(plane, point);
+    multiplyScalar(out, plane.normal, distance);
+    subtract(out, point, out);
+}
+function equals(plane, other) {
+    return vec3equals(plane.normal, other.normal) && Math.abs(plane.distance - other.distance) < EPSILON;
+}
+function fromNormalAndCoplanarPoint(out, normal, point) {
+    vec3copy(out.normal, normal);
+    out.distance = dot(point, normal);
+}
+function fromPoints(out, a, b, c) {
+    subtract(_0vector, b, a);
+    subtract(_1vector, c, a);
+    cross(out.normal, _0vector, _1vector);
+    normalize(out.normal, out.normal);
+    out.distance = dot(out.normal, a);
+}
+function getUnitSphereRadiusAngle(plane) {
+    return Math.acos(Math.max(Math.min(plane.distance, 1), -1));
+}
+export { create, set, fromValues, copy, clone, distanceToPoint, projectPoint, equals, fromNormalAndCoplanarPoint, fromPoints, getUnitSphereRadiusAngle };

package/Math/quaternion.js

@@ -1,101 +1,106 @@
-import { vec3 } from './vec3';
+import { dot } from './vec3';
 import { EPSILON } from './constants';
-export const quaternion = Object.freeze({
-    create(x = 0, y = 0, z = 0, w = 1) {
-        return [x, y, z, w];
-    },
-    set(out, x, y, z, w) {
-        out[0] = x;
-        out[1] = y;
-        out[2] = z;
-        out[3] = w;
-    },
-    copy(out, a) {
-        out[0] = a[0];
-        out[1] = a[1];
-        out[2] = a[2];
-        out[3] = a[3];
-    },
-    clone(a) {
-        return [a[0], a[1], a[2], a[3]];
-    },
-    multiply(out, a, b) {
-        const x = a[0] * b[3] + a[3] * b[0] + a[1] * b[2] - a[2] * b[1];
-        const y = a[1] * b[3] + a[3] * b[1] + a[2] * b[0] - a[0] * b[2];
-        const z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
-        const w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
-        this.set(out, x, y, z, w);
-        return out;
-    },
-    randomUnit(out) {
-        const u1 = Math.random();
-        const u2 = Math.random();
-        const u3 = Math.random();
-        const sqrt1MinusU1 = Math.sqrt(1 - u1);
-        const sqrtU1 = Math.sqrt(u1);
-        const x = sqrt1MinusU1 * Math.sin(2 * Math.PI * u2);
-        const y = sqrt1MinusU1 * Math.cos(2 * Math.PI * u2);
-        const z = sqrtU1 * Math.sin(2 * Math.PI * u3);
-        const w = sqrtU1 * Math.cos(2 * Math.PI * u3);
-        this.set(out, x, y, z, w);
-        this.normalize(out, out);
-        return out;
-    },
-    rotateQuaternion(out, a, b) {
-        const x = a[0] * b[3] + a[3] * b[0] + a[1] * b[2] - a[2] * b[1];
-        const y = a[1] * b[3] + a[3] * b[1] + a[2] * b[0] - a[0] * b[2];
-        const z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
-        const w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
-        this.set(out, x, y, z, w);
-        this.normalize(out, out);
-    },
-    lengthSquared(a) {
-        return a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3];
-    },
-    length(a) {
-        return Math.sqrt(this.lengthSquared(a));
-    },
-    normalize(out, input) {
-        const len = Math.sqrt(this.lengthSquared(input));
-        if (len < EPSILON) {
-            this.set(out, 0, 0, 0, 1);
+function create(x = 0, y = 0, z = 0, w = 1) {
+    return [x, y, z, w];
+}
+function set(out, x, y, z, w) {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    out[3] = w;
+}
+function copy(out, a) {
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    out[3] = a[3];
+}
+function clone(a) {
+    return [a[0], a[1], a[2], a[3]];
+}
+function lengthSquared(a) {
+    return a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3];
+}
+function length(a) {
+    return Math.sqrt(lengthSquared(a));
+}
+function normalize(out, input) {
+    const len = Math.sqrt(lengthSquared(input));
+    if (len < EPSILON) {
+        set(out, 0, 0, 0, 1);
+    }
+    else {
+        const invLen = 1 / len;
+        set(out, input[0] * invLen, input[1] * invLen, input[2] * invLen, input[3] * invLen);
+    }
+}
+function multiply(out, a, b) {
+    const x = a[0] * b[3] + a[3] * b[0] + a[1] * b[2] - a[2] * b[1];
+    const y = a[1] * b[3] + a[3] * b[1] + a[2] * b[0] - a[0] * b[2];
+    const z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
+    const w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
+    set(out, x, y, z, w);
+    return out;
+}
+function randomUnit(out) {
+    const u1 = Math.random();
+    const u2 = Math.random();
+    const u3 = Math.random();
+    const sqrt1MinusU1 = Math.sqrt(1 - u1);
+    const sqrtU1 = Math.sqrt(u1);
+    const x = sqrt1MinusU1 * Math.sin(2 * Math.PI * u2);
+    const y = sqrt1MinusU1 * Math.cos(2 * Math.PI * u2);
+    const z = sqrtU1 * Math.sin(2 * Math.PI * u3);
+    const w = sqrtU1 * Math.cos(2 * Math.PI * u3);
+    set(out, x, y, z, w);
+    normalize(out, out);
+    return out;
+}
+function rotateQuaternion(out, a, b) {
+    const x = a[0] * b[3] + a[3] * b[0] + a[1] * b[2] - a[2] * b[1];
+    const y = a[1] * b[3] + a[3] * b[1] + a[2] * b[0] - a[0] * b[2];
+    const z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
+    const w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
+    set(out, x, y, z, w);
+    normalize(out, out);
+}
+function fromUnitVectors(out, from, to) {
+    const d = dot(from, to) + 1;
+    if (d < EPSILON) {
+        if (Math.abs(from[0]) > Math.abs(from[2])) {
+            set(out, -from[1], from[0], 0, 0);
         }
         else {
-            const invLen = 1 / len;
-            this.set(out, input[0] * invLen, input[1] * invLen, input[2] * invLen, input[3] * invLen);
+            set(out, 0, -from[2], from[1], 0);
         }
-    },
-    fromUnitVectors(out, from, to) {
-        const d = vec3.dot(from, to) + 1;
-        if (d < EPSILON) {
-            if (Math.abs(from[0]) > Math.abs(from[2])) {
-                this.set(out, -from[1], from[0], 0, 0);
-            }
-            else {
-                this.set(out, 0, -from[2], from[1], 0);
-            }
-        }
-        else {
-            const x = from[1] * to[2] - from[2] * to[1];
-            const y = from[2] * to[0] - from[0] * to[2];
-            const z = from[0] * to[1] - from[1] * to[0];
-            this.set(out, x, y, z, d);
-        }
-    },
-    fromTwoQuaternions(out, from, to) {
-        const x = from[0] * to[3] + from[3] * to[0] + from[1] * to[2] - from[2] * to[1];
-        const y = from[1] * to[3] + from[3] * to[1] + from[2] * to[0] - from[0] * to[2];
-        const z = from[2] * to[3] + from[3] * to[2] + from[0] * to[1] - from[1] * to[0];
-        const w = from[3] * to[3] - from[0] * to[0] - from[1] * to[1] - from[2] * to[2];
-        this.set(out, x, y, z, w);
-        this.normalize(out, out);
-    },
-    conjugate(out, a) {
-        this.set(out, -a[0], -a[1], -a[2], a[3]);
-    },
-    fromAxisAngle(out, axis, angle) {
-        const halfAngle = angle / 2;
-        const s = Math.sin(halfAngle);
-        this.set(out, axis[0] * s, axis[1] * s, axis[2] * s, Math.cos(halfAngle));
-    },
-});
+    }
+    else {
+        const x = from[1] * to[2] - from[2] * to[1];
+        const y = from[2] * to[0] - from[0] * to[2];
+        const z = from[0] * to[1] - from[1] * to[0];
+        set(out, x, y, z, d);
+    }
+}
+function fromTwoQuaternions(out, from, to) {
+    const x = from[0] * to[3] + from[3] * to[0] + from[1] * to[2] - from[2] * to[1];
+    const y = from[1] * to[3] + from[3] * to[1] + from[2] * to[0] - from[0] * to[2];
+    const z = from[2] * to[3] + from[3] * to[2] + from[0] * to[1] - from[1] * to[0];
+    const w = from[3] * to[3] - from[0] * to[0] - from[1] * to[1] - from[2] * to[2];
+    set(out, x, y, z, w);
+    normalize(out, out);
+}
+function conjugate(out, a) {
+    set(out, -a[0], -a[1], -a[2], a[3]);
+}
+function fromAxisAngle(out, axis, angle) {
+    const halfAngle = angle / 2;
+    const s = Math.sin(halfAngle);
+    set(out, axis[0] * s, axis[1] * s, axis[2] * s, Math.cos(halfAngle));
+}
+function reverse(out, a) {
+    out[0] = -a[0];
+    out[1] = -a[1];
+    out[2] = -a[2];
+    out[3] = a[3];
+}
+export { create, set, copy, clone, length, lengthSquared, normalize, multiply, randomUnit, rotateQuaternion, fromUnitVectors, fromTwoQuaternions, conjugate, fromAxisAngle, reverse };

package/Math/vec3.js

@@ -1,123 +1,122 @@
 import { EPSILON } from './constants';
-export const vec3 = Object.freeze({
-    create(x = 0, y = 0, z = 1) {
-        return [x, y, z];
-    },
-    set(out, x, y, z) {
-        out[0] = x;
-        out[1] = y;
-        out[2] = z;
-    },
-    clone(a) {
-        return [a[0], a[1], a[2]];
-    },
-    copy(out, a) {
-        out[0] = a[0];
-        out[1] = a[1];
-        out[2] = a[2];
-        return out;
-    },
-    add(out, a, b) {
-        out[0] = a[0] + b[0];
-        out[1] = a[1] + b[1];
-        out[2] = a[2] + b[2];
-        return out;
-    },
-    subtract(out, a, b) {
-        out[0] = a[0] - b[0];
-        out[1] = a[1] - b[1];
-        out[2] = a[2] - b[2];
-    },
-    dot(a, b) {
-        return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-    },
-    cross(out, a, b) {
-        const x = a[1] * b[2] - a[2] * b[1];
-        const y = a[2] * b[0] - a[0] * b[2];
-        const z = a[0] * b[1] - a[1] * b[0];
-        out[0] = x;
-        out[1] = y;
-        out[2] = z;
-    },
-    multiplyScalar(out, a, b) {
-        out[0] = a[0] * b;
-        out[1] = a[1] * b;
-        out[2] = a[2] * b;
-    },
-    divideScalar(out, a, b) {
-        if (b === 0) {
-            throw new Error('Division by zero');
-        }
-        out[0] = a[0] / b;
-        out[1] = a[1] / b;
-        out[2] = a[2] / b;
-    },
-    lengthSquared(a) {
-        return a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
-    },
-    length(a) {
-        return Math.sqrt(this.lengthSquared(a));
-    },
-    normalize(outVec, inVec) {
-        const len = this.length(inVec);
-        if (len === 0) {
-            throw new Error('Cannot normalize a zero vector');
-        }
-        outVec[0] = inVec[0] / len;
-        outVec[1] = inVec[1] / len;
-        outVec[2] = inVec[2] / len;
-    },
-    distanceSquared(a, b) {
-        const dx = a[0] - b[0];
-        const dy = a[1] - b[1];
-        const dz = a[2] - b[2];
-        return dx * dx + dy * dy + dz * dz;
-    },
-    distance(a, b) {
-        return Math.sqrt(this.distanceSquared(a, b));
-    },
-    equals(a, b) {
-        return (Math.abs(a[0] - b[0]) < EPSILON &&
-            Math.abs(a[1] - b[1]) < EPSILON &&
-            Math.abs(a[2] - b[2]) < EPSILON);
-    },
-    toUnitVectorLongLat(out, a) {
-        const len = this.length(a); // TODO Might drop length check 
-        if (len === 0) {
-            throw new Error('Cannot convert a zero vector to unit vector');
-        }
-        out[0] = Math.atan2(a[1], a[0]); // Longitude
-        out[1] = Math.asin(a[2] / len); // Latitude
-    },
-    fromUnitVectorLongLat(out, longLat) {
-        const longitude = longLat[0];
-        const latitude = longLat[1];
-        const cosLat = Math.cos(latitude);
-        out[0] = cosLat * Math.cos(longitude);
-        out[1] = cosLat * Math.sin(longitude);
-        out[2] = Math.sin(latitude);
-    },
-    applyQuaternion(out, a, q) {
-        const x = a[0], y = a[1], z = a[2];
-        const qx = q[0], qy = q[1], qz = q[2], qw = q[3];
-        // Calculate the quaternion multiplication
-        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;
-        // Apply the quaternion to the vector
-        out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;
-        out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;
-        out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;
-    },
-    randomUnit(out) {
-        const theta = Math.random() * 2 * Math.PI;
-        const phi = Math.acos(2 * Math.random() - 1);
-        out[0] = Math.sin(phi) * Math.cos(theta);
-        out[1] = Math.sin(phi) * Math.sin(theta);
-        out[2] = Math.cos(phi);
-    },
-    str(a) {
-        return `Vec3(${a[0].toFixed(2)}, ${a[1].toFixed(2)}, ${a[2].toFixed(2)})`;
+function create(x = 0, y = 0, z = 1) {
+    return [x, y, z];
+}
+function set(out, x, y, z) {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+}
+function clone(a) {
+    return [a[0], a[1], a[2]];
+}
+function copy(out, a) {
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    return out;
+}
+function add(out, a, b) {
+    out[0] = a[0] + b[0];
+    out[1] = a[1] + b[1];
+    out[2] = a[2] + b[2];
+    return out;
+}
+function subtract(out, a, b) {
+    out[0] = a[0] - b[0];
+    out[1] = a[1] - b[1];
+    out[2] = a[2] - b[2];
+}
+function dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross(out, a, b) {
+    const x = a[1] * b[2] - a[2] * b[1];
+    const y = a[2] * b[0] - a[0] * b[2];
+    const z = a[0] * b[1] - a[1] * b[0];
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+}
+function multiplyScalar(out, a, b) {
+    out[0] = a[0] * b;
+    out[1] = a[1] * b;
+    out[2] = a[2] * b;
+}
+function divideScalar(out, a, b) {
+    if (b === 0) {
+        throw new Error('Division by zero');
     }
-});
+    out[0] = a[0] / b;
+    out[1] = a[1] / b;
+    out[2] = a[2] / b;
+}
+function lengthSquared(a) {
+    return a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
+}
+function length(a) {
+    return Math.sqrt(lengthSquared(a));
+}
+function normalize(outVec, inVec) {
+    const len = length(inVec);
+    if (len === 0) {
+        throw new Error('Cannot normalize a zero vector');
+    }
+    outVec[0] = inVec[0] / len;
+    outVec[1] = inVec[1] / len;
+    outVec[2] = inVec[2] / len;
+}
+function distanceSquared(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    const dz = a[2] - b[2];
+    return dx * dx + dy * dy + dz * dz;
+}
+function distance(a, b) {
+    return Math.sqrt(distanceSquared(a, b));
+}
+function equals(a, b) {
+    return (Math.abs(a[0] - b[0]) < EPSILON &&
+        Math.abs(a[1] - b[1]) < EPSILON &&
+        Math.abs(a[2] - b[2]) < EPSILON);
+}
+function toUnitVectorLongLat(out, a) {
+    const len = length(a); // TODO Might drop length check 
+    if (len === 0) {
+        throw new Error('Cannot convert a zero vector to unit vector');
+    }
+    out[0] = Math.atan2(a[1], a[0]); // Longitude
+    out[1] = Math.asin(a[2] / len); // Latitude
+}
+function fromUnitVectorLongLat(out, longLat) {
+    const longitude = longLat[0];
+    const latitude = longLat[1];
+    const cosLat = Math.cos(latitude);
+    out[0] = cosLat * Math.cos(longitude);
+    out[1] = cosLat * Math.sin(longitude);
+    out[2] = Math.sin(latitude);
+}
+function applyQuaternion(out, a, q) {
+    const x = a[0], y = a[1], z = a[2];
+    const qx = q[0], qy = q[1], qz = q[2], qw = q[3];
+    // Calculate the quaternion multiplication
+    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;
+    // Apply the quaternion to the vector
+    out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+    out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+    out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+}
+function randomUnit(out) {
+    const theta = Math.random() * 2 * Math.PI;
+    const phi = Math.acos(2 * Math.random() - 1);
+    out[0] = Math.sin(phi) * Math.cos(theta);
+    out[1] = Math.sin(phi) * Math.sin(theta);
+    out[2] = Math.cos(phi);
+}
+function str(a) {
+    return `Vec3(${a[0].toFixed(2)}, ${a[1].toFixed(2)}, ${a[2].toFixed(2)})`;
+}
+export { create, set, clone, copy, add, subtract, dot, cross, multiplyScalar, divideScalar, lengthSquared, length, normalize, distanceSquared, distance, equals, toUnitVectorLongLat, fromUnitVectorLongLat, applyQuaternion, randomUnit, str };

package/heatwave/plugins/heatwaveglobeshell.js

@@ -1,4 +1,5 @@
-import { getColorRampModed, DataManager, PointCoordinatesDataCalculator } from "../../util";
+import { getColorRampModed, DataManager, } from "../../util/index";
+import { TexturePointSampler } from "../../util/heatwavedatamanager/texture-point-sampler";
 import { GlobeShellWiggle, Float2LegendWithRatio } from "../../programs";
 import { opacityCheck } from "../../util/check/typecheck";
 /**
@@ -50,9 +51,9 @@ export default class HeatWaveGlobeShellPlugin {
         this._escapeValue = escapeValue;
         this.heatProgram.setEscapeValue(escapeValue);
     }
-    _createPointCoordinatesDataCalculator() {
-        this.coordinatesDataCalculator = new PointCoordinatesDataCalculator(this._bbox, this._dataWidthHeight.width, this._dataWidthHeight.height);
-        this.dataManager.register(this._coordinatesDataCalculatorID(), this.coordinatesDataCalculator.updateData.bind(this.coordinatesDataCalculator));
+    _createTexturePointSampler() {
+        this.coordinatesDataCalculator = new TexturePointSampler(this._bbox, this._dataWidthHeight.width, this._dataWidthHeight.height);
+        this.dataManager.register(this._coordinatesDataCalculatorID(), this.coordinatesDataCalculator.updateTextureData.bind(this.coordinatesDataCalculator));
     }
     _coordinatesDataCalculatorID() {
         return this.id + "_coordinatesDataCalculator";
@@ -77,9 +78,9 @@ export default class HeatWaveGlobeShellPlugin {
         this.globeShell.setBBox({ minLon, minLat, maxLon, maxLat });
         this.drawHeat();
     }
-    getPointCoordinatesDataCalculator() {
+    getTexturePointSampler() {
         if (!this.coordinatesDataCalculator)
-            this._createPointCoordinatesDataCalculator();
+            this._createTexturePointSampler();
         return this.coordinatesDataCalculator;
     }
     /**

package/package.json

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

package/programs/index.js

@@ -3,7 +3,7 @@ import { GlobeShellWiggle } from "./globeshell/wiggle";
 import { CameraUniformBlockTotem, CameraUniformBlockString } from "./totems/index";
 import ArrowField from "./arrowfield";
 import { glProgramCache, globeProgramCache, noRegisterGlobeProgramCache } from "./programcache";
-import * as vectorfield from "./vectorfields";
+import * as vectorfield from "./vectorfields/index";
 import { FadeAway } from "./helpers";
 import * as rings from "./rings";
 export { Float2LegendWithRatio, GlobeShellWiggle, ArrowField, CameraUniformBlockTotem, CameraUniformBlockString, glProgramCache, globeProgramCache, noRegisterGlobeProgramCache, vectorfield, FadeAway, rings };

package/programs/vectorfields/logics/drawrectangleparticles.js

@@ -88,17 +88,11 @@ class Logic {
         this.program = null;
     }
 }
-export default class {
-    constructor(gl) {
-        this.gl = gl;
-        this.logic = glProgramCache.getProgram(gl, Logic);
-    }
-    draw(bufferManager, vectorTexture, uboManager) {
-        this.logic.draw(bufferManager, vectorTexture, uboManager);
+export const drawRectangleParticlesProgramCache = Object.freeze({
+    getProgram: (gl) => {
+        return glProgramCache.getProgram(gl, Logic);
+    },
+    releaseProgram: (gl) => {
+        glProgramCache.releaseProgram(gl, Logic);
     }
-    free() {
-        glProgramCache.releaseProgram(this.gl, Logic);
-        this.logic = null;
-        this.gl = null;
-    }
-}
+});

package/programs/vectorfields/logics/index.js

@@ -1,4 +1,2 @@
-import PixelBasedMove from './pixelbased';
-import DrawRectangleParticles from './drawrectangleparticles';
 import { WaveParticalUboManager } from './ubo';
-export { PixelBasedMove, DrawRectangleParticles, WaveParticalUboManager };
+export { WaveParticalUboManager };