@pirireis/webglobeplugins 1.0.2 → 1.0.3

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

@@ -1,92 +1,56 @@
-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
-}
+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 };

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

@@ -1,128 +1,106 @@
-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
-}
+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 };

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

@@ -1,118 +1,65 @@
-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;
-}
+/**
+ * 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;
+}

package/Math/tessellation/constants.js

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