@pirireis/webglobeplugins 0.9.1 → 0.9.2

package/Math/quaternion.ts

@@ -1,159 +1,123 @@
-import { Radians, Vector3D } from './types'
-
-
-export class Quaternion {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-
-
-
-    constructor(x: number = 0, y: number = 0, z: number = 0, w: number = 1) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-        this.w = w;
-    }
-
-
-
-    set(x: number, y: number, z: number, w: number): Quaternion {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-        this.w = w;
-        return this;
-    }
-
-
-
-    multiply(other: Quaternion): Quaternion {
-        const x = this.x * other.w + this.w * other.x + this.y * other.z - this.z * other.y;
-        const y = this.y * other.w + this.w * other.y + this.z * other.x - this.x * other.z;
-        const z = this.z * other.w + this.w * other.z + this.x * other.y - this.y * other.x;
-        const w = this.w * other.w - this.x * other.x - this.y * other.y - this.z * other.z;
-        return this.set(x, y, z, w);
-    }
-
-
-
-    length(): number {
-        return Math.sqrt(this.x ** 2 + this.y ** 2 + this.z ** 2 + this.w ** 2);
-    }
-
-
-
-    normalize(): Quaternion {
-        const len = this.length();
-        if (len > 0) {
-            this.x /= len;
-            this.y /= len;
-            this.z /= len;
-            this.w /= len;
+import { Vec3, Quaternion } from './types';
+import { vec3 } from './vec3';
+import { EPSILON } from './constants';
+
+export const quaternion = Object.freeze({
+    create(x = 0, y = 0, z = 0, w = 1): Quaternion {
+        return [x, y, z, w];
+    },
+
+    set(out: Quaternion, x: number, y: number, z: number, w: number) {
+        out[0] = x;
+        out[1] = y;
+        out[2] = z;
+        out[3] = w;
+    },
+
+    copy(out: Quaternion, a: Quaternion) {
+        out[0] = a[0];
+        out[1] = a[1];
+        out[2] = a[2];
+        out[3] = a[3];
+    },
+
+    clone(a: Quaternion): Quaternion {
+        return [a[0], a[1], a[2], a[3]];
+    },
+
+
+    multiply(out: Quaternion, a: Quaternion, b: Quaternion): Quaternion {
+        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: Quaternion): Quaternion {
+        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: Quaternion, a: Quaternion, b: Quaternion) {
+        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);
+    },
+
+    lengthSquared(a: Quaternion): number {
+        return a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3];
+    },
+
+    length(a: Quaternion): number {
+        return Math.sqrt(this.lengthSquared(a));
+    },
+
+    normalize(out: Quaternion) {
+        const len = Math.sqrt(this.lengthSquared(out));
+        if (len < EPSILON) {
+            this.set(out, 0, 0, 0, 1);
         }
-        return this;
-    }
-
-
-
-    copy(other: Quaternion): Quaternion {
-        this.x = other.x;
-        this.y = other.y;
-        this.z = other.z;
-        this.w = other.w;
-        return this;
-    }
-
-
-
-    clone(): Quaternion {
-        return new Quaternion(this.x, this.y, this.z, this.w);
-    }
-
+        else {
+            const invLen = 1 / len;
+            out[0] *= invLen;
+            out[1] *= invLen;
+            out[2] *= invLen;
+            out[3] *= invLen;
+        }
+    },
 
+    fromUnitVectors(out: Quaternion, from: Vec3, to: Vec3) {
 
-    setFromUnitVectors(vFrom: Vector3D, vTo: Vector3D): Quaternion {
-        const d = vFrom.dot(vTo) + 1;
-        if (d < 0.000001) {
-            if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
-                this.set(-vFrom.y, vFrom.x, 0, 0);
+        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(0, -vFrom.z, vFrom.y, 0);
+                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);
         }
-        else {
-            this.set(
-                vFrom.y * vTo.z - vFrom.z * vTo.y,
-                vFrom.z * vTo.x - vFrom.x * vTo.z,
-                vFrom.x * vTo.y - vFrom.y * vTo.x,
-                d
-            )
-        }
-        return this;
-    }
-
-
+    },
 
-    static fromUnitVectors(vFrom: Vector3D, vTo: Vector3D): Quaternion {
-        return new Quaternion().setFromUnitVectors(vFrom, vTo);
-    }
 
+    fromTwoQuaternions(out: Quaternion, from: Quaternion, to: Quaternion) {
+        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);
+    },
 
+    conjugate(out: Quaternion, a: Quaternion) {
+        this.set(out, -a[0], -a[1], -a[2], a[3]);
+    },
 
-    setFromAxisAngle(axis: Vector3D, angle: Radians): Quaternion {
+    fromAxisAngle(out: Quaternion, axis: Vec3, angle: number) {
         const halfAngle = angle / 2;
         const s = Math.sin(halfAngle);
-        const len = axis.length() || 1;
-        this.x = axis.x * s / len;
-        this.y = axis.y * s / len;
-        this.z = axis.z * s / len;
-        this.w = Math.cos(halfAngle);
-        return this;
-    }
-
-
-
-    static fromAxisAngle(axis: Vector3D, angle: Radians): Quaternion {
-        return new Quaternion().setFromAxisAngle(axis, angle);
-    }
-
-
-
-    rotatePoint(point: Vector3D, out: Vector3D) {
-        const x = point.x;
-        const y = point.y;
-        const z = point.z;
-
-        const qx = this.x;
-        const qy = this.y;
-        const qz = this.z;
-        const qw = this.w;
-
-        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;
-
-        out.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
-        out.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
-        out.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
-
-        return out;
-
-    }
-
+        this.set(out, axis[0] * s, axis[1] * s, axis[2] * s, Math.cos(halfAngle));
+    },
 
-    toMatrix4x4(): number[] {
-        const x = this.x, y = this.y, z = this.z, w = this.w;
-        const xx = x * x, yy = y * y, zz = z * z, xy = x * y, xz = x * z, yz = y * z, wx = w * x, wy = w * y, wz = w * z;
-        return [
-            1 - 2 * (yy + zz), 2 * (xy - wz), 2 * (xz + wy), 0,
-            2 * (xy + wz), 1 - 2 * (xx + zz), 2 * (yz - wx), 0,
-            2 * (xz - wy), 2 * (yz + wx), 1 - 2 * (xx + yy), 0,
-            0, 0, 0, 1
-        ];
-    }
 
+});
 
-}

package/Math/types.ts

@@ -1,36 +1,45 @@
-export type Radians = number;
-export type Degrees = number;
-export type Meter = number;
-
-interface Vector3D {
-    x: number;
-    y: number;
-    z: number;
-    dot(other: Vector3D): number;
-    cross(other: Vector3D): Vector3D;
-    lerp(other: Vector3D, t: number): Vector3D;
-    scale(scalar: number): Vector3D;
-    applyQuaternion(q: Quaternion): Vector3D;
-    normalize(): Vector3D;
-    clone(): Vector3D;
-    copy(other: Vector3D): Vector3D;
-    set(x: number, y: number, z: number): Vector3D;
-    add(other: Vector3D): Vector3D;
-    subtract(other: Vector3D): Vector3D;
-    negate(): Vector3D;
-    length(): number;
-    multiplyByScaler(scalar: number): Vector3D;
-    divideByScaler(scalar: number): Vector3D;
+type Radians = number;
+type Degrees = number;
+type Meter = number;
+
+
+type Vec3 = [number, number, number];
+
+type Line = {
+    origin: Vec3;
+    direction: Vec3;
+}
+
+type Plane = {
+    normal: Vec3;
+    distance: number;
+};
+
+type LongLat = [number, number]; // [longitude, latitude]
+
+type Quaternion = [number, number, number, number];
+
+type Arc = {
+    p0: Vec3;
+    p1: Vec3;
+    normal: Vec3;
+    coverPlane: Plane;
 }
 
-interface Quaternion {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
+type Sphere = {
+    center: Vec3;
+    radius: number;
 }
 
 export {
-    Vector3D,
-    Quaternion
+    Vec3,
+    Line,
+    Plane,
+    Quaternion,
+    Arc,
+    Sphere,
+    Radians,
+    Degrees,
+    Meter,
+    LongLat,
 }

package/Math/vec3.ts

@@ -0,0 +1,155 @@
+import { Vec3, LongLat, Quaternion } from './types';
+import { EPSILON } from './constants';
+
+export const vec3 = Object.freeze({
+    create(x = 0, y = 0, z = 1): Vec3 {
+        return [x, y, z];
+    },
+
+    set(out: Vec3, x: number, y: number, z: number) {
+        out[0] = x;
+        out[1] = y;
+        out[2] = z;
+    },
+
+    clone(a: Vec3): Vec3 {
+        return [a[0], a[1], a[2]];
+    },
+
+    copy(out: Vec3, a: Vec3): Vec3 {
+        out[0] = a[0];
+        out[1] = a[1];
+        out[2] = a[2];
+        return out;
+    },
+
+    add(out: Vec3, a: Vec3, b: Vec3): Vec3 {
+        out[0] = a[0] + b[0];
+        out[1] = a[1] + b[1];
+        out[2] = a[2] + b[2];
+        return out;
+    },
+
+    subtract(out: Vec3, a: Vec3, b: Vec3) {
+        out[0] = a[0] - b[0];
+        out[1] = a[1] - b[1];
+        out[2] = a[2] - b[2];
+    },
+
+    dot(a: Vec3, b: Vec3): number {
+        return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+    },
+
+    cross(out: Vec3, a: Vec3, b: Vec3) {
+        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: Vec3, a: Vec3, b: number) {
+        out[0] = a[0] * b;
+        out[1] = a[1] * b;
+        out[2] = a[2] * b;
+    },
+
+    divideScalar(out: Vec3, a: Vec3, b: number) {
+        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: Vec3): number {
+        return a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
+    },
+
+    length(a: Vec3): number {
+        return Math.sqrt(this.lengthSquared(a));
+    },
+
+    normalize(outVec: Vec3, inVec: Vec3) {
+        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: Vec3, b: Vec3): number {
+        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: Vec3, b: Vec3): number {
+        return Math.sqrt(this.distanceSquared(a, b));
+    },
+
+    equals(a: Vec3, b: Vec3): boolean {
+        return (
+            Math.abs(a[0] - b[0]) < EPSILON &&
+            Math.abs(a[1] - b[1]) < EPSILON &&
+            Math.abs(a[2] - b[2]) < EPSILON
+        );
+    },
+
+
+    toUnitVectorLongLat(out: LongLat, a: Vec3) {
+        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: Vec3, longLat: 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: Vec3, a: Vec3, q: Quaternion) {
+        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: Vec3) {
+        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: Vec3): string {
+        return `Vec3(${a[0].toFixed(2)}, ${a[1].toFixed(2)}, ${a[2].toFixed(2)})`;
+    }
+
+
+});

package/altitude-locator/plugin.js

@@ -11,7 +11,7 @@ import { BufferOrchestrator, BufferManager } from "../util/account";
 import { PickerDisplayer } from '../util/picking/picker-displayer.js';
 import { wgs84ToCartesian3d, wgs84ToMercator } from '../Math/methods.js';
 import { constraintFloat, opacityCheck } from '../util/check/typecheck.js';
-import { createBufferAndReadInfo } from '../util/gl-util/buffer/integrate-buffer.js';
+import { createBufferAndReadInfo } from '../util/gl-util/buffer/attribute-loader';
 import { CameraUniformBlockTotemCache } from '../programs/totems/camerauniformblock.js';
 
 /**

package/bearing-line/plugin.js

@@ -8,7 +8,7 @@ import { populateFloat32Array } from "../util/jshelpers/data-filler";
 import { ContextTextWriter3 } from '../write-text/context-text3'
 import { constraintFloat, isBoolean } from '../util/check/typecheck';
 import { sphereCoord } from '../util/geometry';
-import { createBufferAndReadInfo } from '../util/gl-util/buffer/integrate-buffer';
+import { createBufferAndReadInfo } from '../util/gl-util/buffer/attribute-loader';
 
 export const RINGPARTIAL_DRAW_MODE = Object.freeze({
     LINE_STRIP: "LINE_STRIP",

package/circle-line-chain/plugin.js

@@ -8,7 +8,7 @@ import { keyMethod } from "./util";
 import { populateFloat32Array } from "../util/jshelpers/data-filler";
 import { ContextTextWriter3 } from '../write-text/context-text3';
 import { isBoolean, constraintFloat, opacityCheck } from '../util/check/typecheck';
-import { createBufferAndReadInfo } from '../util/gl-util/buffer/integrate-buffer';
+import { createBufferAndReadInfo } from '../util/gl-util/buffer/attribute-loader';
 import { sphereCoord } from '../util/geometry/index';
 /**
  * Insert info to chain list map (nodes and properties)

package/globe-types.ts

@@ -0,0 +1,13 @@
+
+
+type Degree = number;
+type Meter = number;
+
+
+type GlobeLookInfo = {
+    CenterLong: Degree;
+    CenterLat: Degree;
+    Distance: Meter;
+    Tilt: Degree;
+    NorthAng: Degree;
+}

package/heatwave/plugins/heatwaveglobeshell.js

@@ -38,7 +38,7 @@ export default class HeatWaveGlobeShellPlugin {
         // output of heatProgram is written to ._coloredHeatTexture
         this._frameBuffer = null
         this._coloredHeatTexture = null;
-
+        this.enabled = false;
         this.isAble = false;
     }
 
@@ -185,14 +185,10 @@ export default class HeatWaveGlobeShellPlugin {
 
 
     _setAfterInit() {
-        {
-            const [minLon, minLat, maxLon, maxLat] = this._bbox;
-            this.globeShell.setBBox({ minLon, minLat, maxLon, maxLat });
-        }
-        {
-            this.setColorRamp(this._colorRampData.values, this._colorRampData.thresholds, this._colorRampData.mode);
-            delete this._colorRampData;
-        }
+        const [minLon, minLat, maxLon, maxLat] = this._bbox;
+        this.globeShell.setBBox({ minLon, minLat, maxLon, maxLat });
+        this.setColorRamp(this._colorRampData.values, this._colorRampData.thresholds, this._colorRampData.mode);
+        delete this._colorRampData;
         this.setMinMaxEdges(this._minMaxEdges.min, this._minMaxEdges.max);
         this.setEscapeValue(this._escapeValue);
     }

package/index.js

@@ -9,4 +9,7 @@ import * as heatwave from "./heatwave";
 import * as util from "./util";
 import * as programs from "./programs";
 import * as pointheatmap from "./point-heat-map";
+
+
+
 export { wind, waveparticles, timetracks, rangerings, compassrose, heatwave, util, programs, arrowfield, partialring, pointheatmap };

package/package.json

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

package/programs/interface.ts

@@ -0,0 +1,7 @@
+
+interface ProgramInterface {
+    draw(vao: WebGLVertexArrayObject, drawOptions: DrawRangeIndexParams, opacity: number, flexibleUBO: UBOHandler | null): void;
+    createUBO(bufferReadType?: "STATIC_DRAW" | "DYNAMIC_DRAW" | "STREAM_DRAW"): UBOHandler;
+    createVAO(...inputs: BufferAndReadInfo[]): WebGLVertexArrayObject;
+    free(): void;
+}

package/programs/line-on-globe/circle-accurate-3d.js

@@ -2,7 +2,7 @@ import { createProgram } from "../../util/webglobjectbuilders";
 import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../totems/camerauniformblock";
 import { noRegisterGlobeProgramCache } from "../programcache";
 // import { vaoAttributeLoader } from "../../util/account/util";
-import { attributeLoader } from "../../util/gl-util/buffer/integrate-buffer";
+import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
 import {
     cartesian3DToGLPosition,
     circleLimpFromLongLatRadCenterCartesian3D_accurate,

package/programs/line-on-globe/degree-padding-around-circle-3d.js

@@ -2,7 +2,7 @@ import { createProgram } from "../../util/webglobjectbuilders";
 import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../totems/camerauniformblock";
 import { noRegisterGlobeProgramCache } from "../programcache";
 // import { vaoAttributeLoader } from "../../util/account/util";
-import { attributeLoader } from "../../util/gl-util/buffer/integrate-buffer";
+import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
 import { Z_ALPHA_MODE } from "./util";
 import {
     cartesian3DToGLPosition,

package/programs/line-on-globe/lines-color-instanced-flat.js

@@ -3,7 +3,7 @@ import { mercatorXYToGLPosition, POLE } from "../../util/shaderfunctions/geometr
 import { noRegisterGlobeProgramCache } from "../programcache";
 import { createProgram } from "../../util";
 import { Z_ALPHA_MODE } from "./util";
-import { attributeLoader } from "../../util/gl-util/buffer/integrate-buffer";
+import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
 
 /**
  * This program draws line between points provided from the first and second buffer.