@pirireis/webglobeplugins 0.17.1 → 1.0.2

package/Math/{plane.js → plane.ts}

@@ -1,56 +1,92 @@
-import { EPSILON } from "./constants";
-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 };
+import { Vec3, Plane } from "./types";
+
+import { EPSILON } from "./constants";
+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): Plane {
+    return {
+        normal: vec3clone(normal),
+        distance: distance
+    };
+}
+
+
+function set(out: Plane, normal: Vec3, distance: number): Plane {
+    vec3copy(out.normal, normal);
+    out.distance = distance;
+    return out;
+}
+
+
+function fromValues(out: Plane, nx: number, ny: number, nz: number, distance: number) {
+    vec3set(out.normal, nx, ny, nz);
+    out.distance = distance;
+}
+
+
+function copy(out: Plane, a: Plane): Plane {
+    vec3copy(out.normal, a.normal);
+    out.distance = a.distance;
+    return out;
+}
+
+
+function clone(a: Plane): Plane {
+    return {
+        normal: vec3clone(a.normal),
+        distance: a.distance
+    };
+}
+
+
+function distanceToPoint(plane: Plane, point: Vec3): number {
+    return dot(plane.normal, point) - plane.distance;
+}
+
+
+function projectPoint(out: Vec3, plane: Plane, point: Vec3) {
+    const distance = distanceToPoint(plane, point);
+    multiplyScalar(out, plane.normal, distance);
+    subtract(out, point, out);
+}
+
+
+function equals(plane: Plane, other: Plane): boolean {
+    return vec3equals(plane.normal, other.normal) && Math.abs(plane.distance - other.distance) < EPSILON;
+}
+
+
+
+function fromNormalAndCoplanarPoint(out: Plane, normal: Vec3, point: Vec3) {
+    vec3copy(out.normal, normal);
+    out.distance = dot(point, normal);
+}
+
+
+
+function fromPoints(out: Plane, a: Vec3, b: Vec3, c: Vec3) {
+    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: Plane): number {
+    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 → quaternion.ts}

@@ -1,106 +1,128 @@
-import { dot } from './vec3';
-import { EPSILON } from './constants';
-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 {
-            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];
-        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 };
+import { Vec3, Quaternion } from './types';
+import { dot } from './vec3';
+import { EPSILON } from './constants';
+
+function create(x = 0, y = 0, z = 0, w = 1): Quaternion {
+    return [x, y, z, w];
+}
+
+function set(out: Quaternion, x: number, y: number, z: number, w: number) {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    out[3] = w;
+}
+
+function copy(out: Quaternion, a: Quaternion) {
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    out[3] = a[3];
+}
+
+function clone(a: Quaternion): Quaternion {
+    return [a[0], a[1], a[2], a[3]];
+}
+function lengthSquared(a: Quaternion): number {
+    return a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3];
+}
+
+function length(a: Quaternion): number {
+    return Math.sqrt(lengthSquared(a));
+}
+
+function normalize(out: Quaternion, input: Quaternion) {
+    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: 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];
+    set(out, x, y, z, w);
+    return out;
+}
+
+function 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);
+    set(out, x, y, z, w);
+    normalize(out, out);
+    return out;
+}
+
+function 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];
+    set(out, x, y, z, w);
+    normalize(out, out);
+}
+
+
+function fromUnitVectors(out: Quaternion, from: Vec3, to: Vec3) {
+
+    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 {
+            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];
+        set(out, x, y, z, d);
+    }
+}
+
+
+function 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];
+    set(out, x, y, z, w);
+    normalize(out, out);
+}
+
+function conjugate(out: Quaternion, a: Quaternion) {
+    set(out, -a[0], -a[1], -a[2], a[3]);
+}
+
+function fromAxisAngle(out: Quaternion, axis: Vec3, angle: number) {
+    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: Quaternion, a: Quaternion) {
+    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/roadmap.md

@@ -0,0 +1,10 @@
+
+There is an arc on a unit sphere. The sphere center is at the origin. The arc is represented with start and points. 
+
+And there is a plane the intersects with the same sphere. Represented with vector and distance from origin.
+
+I want to know the relative position of points to the plane. If they are at the same direction with the plane vector or not. 
+
+If two points are on the same side of the plane. If so, do they closer to origin then plane or not. 
+
+If two points are on different side of the plane, I want to know the intersection point of arc and plane.

package/Math/templete-shapes/{grid-visually-equal.js → grid-visually-equal.ts}

@@ -1,65 +1,118 @@
-/**
- * Createa a grıd of longitude/latitude points visually equal on the mercator projectıon.
- */
-function mercatorMeterToLongLat(mercatorX, mercatorY) {
-    const R = 6378137; // Earth radius in meters
-    const lng = (mercatorX / R) * (180 / Math.PI);
-    const lat = (2 * Math.atan(Math.exp(mercatorY / R)) - Math.PI / 2) * (180 / Math.PI);
-    return [lng, lat];
-}
-function createGrid(sizeX, sizeY) {
-    const grid = [];
-    for (let y = 0; y < sizeY; y++) {
-        const row = new Array(sizeX);
-        grid.push(row);
-    }
-    return grid;
-}
-function moveByAngle(origin, angle, distance) {
-    const long = origin[0] + distance * Math.cos(angle);
-    const lat = origin[1] + distance * Math.sin(angle);
-    return [long, lat];
-}
-export function createfillGrid(globe, origin, startX, startY, rowSize, columnSize, cellSizeX, cellSizeY, rotaionAngle = 0) {
-    const originMercator = globe.api_GetMercator2DPoint(origin[0], origin[1]);
-    const angleRadians = rotaionAngle * (Math.PI / 180);
-    const grid = createGrid(rowSize, columnSize);
-    // Set the origin point first
-    grid[startY][startX] = originMercator;
-    // fill single vertical row from origin - to the right
-    let lastPoint = originMercator;
-    for (let i = startX + 1; i < rowSize; i++) {
-        const [long, lat] = moveByAngle(lastPoint, angleRadians, cellSizeX);
-        lastPoint = [long, lat];
-        grid[startY][i] = [long, lat];
-    }
-    // fill single vertical row from origin - to the left
-    lastPoint = originMercator;
-    for (let i = startX - 1; i >= 0; i--) {
-        const [long, lat] = moveByAngle(lastPoint, Math.PI + angleRadians, cellSizeX);
-        lastPoint = [long, lat];
-        grid[startY][i] = [long, lat];
-    }
-    // fill single horizontal from origin from startY to 0
-    for (let i = startY - 1; i >= 0; i--) {
-        for (let j = 0; j < rowSize; j++) {
-            const [long, lat] = moveByAngle(grid[i + 1][j], angleRadians - Math.PI / 2, cellSizeY);
-            grid[i][j] = [long, lat];
-        }
-    }
-    // fill single horizontal from origin from startY to last row
-    for (let i = startY + 1; i < columnSize; i++) {
-        for (let j = 0; j < rowSize; j++) {
-            const [long, lat] = moveByAngle(grid[i - 1][j], angleRadians + Math.PI / 2, cellSizeY);
-            grid[i][j] = [long, lat];
-        }
-    }
-    // Convert from mercator meters to longitude/latitude
-    for (let i = 0; i < columnSize; i++) {
-        for (let j = 0; j < rowSize; j++) {
-            const [long, lat] = mercatorMeterToLongLat(grid[i][j][0], grid[i][j][1]);
-            grid[i][j] = [long, lat];
-        }
-    }
-    return grid;
-}
+import { Globe, Meter, Radian, CentigradeDegree, LongLatDegree } from "../../types";
+
+
+
+/**
+ * Createa a grıd of longitude/latitude points visually equal on the mercator projectıon.
+ */
+
+function mercatorMeterToLongLat(
+    mercatorX: number,
+    mercatorY: number
+): LongLatDegree {
+    const R = 6378137; // Earth radius in meters
+    const lng = (mercatorX / R) * (180 / Math.PI);
+    const lat = (2 * Math.atan(Math.exp(mercatorY / R)) - Math.PI / 2) * (180 / Math.PI);
+    return [lng, lat];
+}
+
+
+function createGrid(sizeX: number, sizeY: number): [number, number][][] {
+    const grid: [number, number][][] = [];
+    for (let y = 0; y < sizeY; y++) {
+        const row = new Array<[number, number]>(sizeX);
+        grid.push(row);
+    }
+
+    return grid;
+}
+
+function moveByAngle(
+    origin: [Meter, Meter],
+    angle: Radian,
+    distance: Meter
+): [Meter, Meter] {
+    const long = origin[0] + distance * Math.cos(angle);
+    const lat = origin[1] + distance * Math.sin(angle);
+    return [long, lat];
+}
+
+
+
+export function createfillGrid(
+    globe: Globe,
+    origin: LongLatDegree,
+    startX: number, startY: number,
+    rowSize: number, columnSize: number,
+    cellSizeX: Meter, cellSizeY: Meter,
+    rotaionAngle: CentigradeDegree = 0
+): [Meter, Meter][][] {
+
+    const originMercator = globe.api_GetMercator2DPoint(origin[0], origin[1]);
+    const angleRadians = rotaionAngle * (Math.PI / 180);
+    const grid = createGrid(rowSize, columnSize);
+
+    // Set the origin point first
+    grid[startY][startX] = originMercator;
+
+    // fill single vertical row from origin - to the right
+    let lastPoint = originMercator;
+    for (let i = startX + 1; i < rowSize; i++) {
+        const [long, lat] = moveByAngle(
+            lastPoint,
+            angleRadians,
+            cellSizeX
+        );
+        lastPoint = [long, lat];
+        grid[startY][i] = [long, lat];
+    }
+
+    // fill single vertical row from origin - to the left
+    lastPoint = originMercator;
+    for (let i = startX - 1; i >= 0; i--) {
+        const [long, lat] = moveByAngle(
+            lastPoint,
+            Math.PI + angleRadians,
+            cellSizeX
+        );
+        lastPoint = [long, lat];
+        grid[startY][i] = [long, lat];
+    }
+
+    // fill single horizontal from origin from startY to 0
+
+    for (let i = startY - 1; i >= 0; i--) {
+        for (let j = 0; j < rowSize; j++) {
+            const [long, lat] = moveByAngle(
+                grid[i + 1][j],
+                angleRadians - Math.PI / 2,
+                cellSizeY
+            );
+            grid[i][j] = [long, lat];
+        }
+    }
+
+    // fill single horizontal from origin from startY to last row
+    for (let i = startY + 1; i < columnSize; i++) {
+        for (let j = 0; j < rowSize; j++) {
+            const [long, lat] = moveByAngle(
+                grid[i - 1][j],
+                angleRadians + Math.PI / 2,
+                cellSizeY
+            );
+            grid[i][j] = [long, lat];
+        }
+    }
+
+    // Convert from mercator meters to longitude/latitude
+    for (let i = 0; i < columnSize; i++) {
+        for (let j = 0; j < rowSize; j++) {
+            const [long, lat] = mercatorMeterToLongLat(
+                grid[i][j][0],
+                grid[i][j][1]
+            );
+            grid[i][j] = [long, lat];
+        }
+    }
+    return grid;
+}

package/Math/tessellation/constants.ts

@@ -0,0 +1 @@
+export const TILE_COUNTS = Array.from({length: 22}, (_, i) => Math.pow(2, i  ));