@pirireis/webglobeplugins 0.16.4 → 0.17.0

package/Math/tessellation/triangle-tessellation-meta.js

@@ -0,0 +1,516 @@
+/**
+ * @author Toprak Ozturk
+ */
+import { create as createArc, calculateZLimitPoint } from "../arc";
+import { createUnitVectorFromLongLat, equals, length, vec3ToLongLatRadians } from "../vec3";
+import { TILE_COUNTS } from "./zoom-catch";
+import { pointsOnArc } from "../juction/arc-plane";
+import { latToTileY, tileYtoLat } from "./methods";
+import { isOnTileEdge } from "./methods";
+import Delaunator from "delaunator";
+// TODO:get rid of embedded lists. always flat list
+const TILE_DEM_VERTEX_COUNT = 5; // 5x5 grid for DEM
+const TILE_DEM_STEPCOUNT = TILE_DEM_VERTEX_COUNT - 1; // 4 inner divisions in each dimension
+const _plane = /*@__PURE__*/ { normal: [0, 0, 0], distance: 0 };
+const _resultPoints = /*@__PURE__*/ [[0, 0, 0], [0, 0, 0]];
+function createShellPoints(triangleMeta) {
+    const arcs = triangleMeta.arcs;
+    const points = [
+        arcs[0].p0LongLat,
+        arcs[1].p0LongLat,
+        arcs[2].p0LongLat
+    ];
+    for (let i = 0; i < 3; i++) {
+        if (arcs[i].exceededLimit) {
+            if (arcs[i].exceededLimit !== undefined) {
+                const longLat = vec3ToLongLatRadians(arcs[i].exceededLimit);
+                points.push(longLat);
+            }
+        }
+    }
+    const center = [
+        points.reduce((sum, p) => sum + p[0], 0) / points.length,
+        points.reduce((sum, p) => sum + p[1], 0) / points.length
+    ];
+    const shellPoints = [];
+    for (let i = 0; i < points.length; i++) {
+        const p = points[i];
+        const x = (p[0] - center[0]) / 10;
+        const y = (p[1] - center[1]) / 10;
+        shellPoints.push([p[0] + x, p[1] + y]);
+    }
+    return shellPoints;
+}
+function createBBox(p1, p2, limitVec) {
+    if (limitVec) {
+        const limitLongLat = vec3ToLongLatRadians(limitVec);
+        console.log('Limit point found at:', limitLongLat, 'for p1:', p1, 'p2:', p2);
+        return {
+            min: [Math.min(p1[0], p2[0], limitLongLat[0]), Math.min(p1[1], p2[1], limitLongLat[1])],
+            max: [Math.max(p1[0], p2[0], limitLongLat[0]), Math.max(p1[1], p2[1], limitLongLat[1])],
+        };
+    }
+    return {
+        min: [Math.min(p1[0], p2[0]), Math.min(p1[1], p2[1])],
+        max: [Math.max(p1[0], p2[0]), Math.max(p1[1], p2[1])],
+    };
+}
+export function createTriangleTessellationMeta(p1, p2, p3) {
+    const p1v3 = createUnitVectorFromLongLat(p1);
+    const p2v3 = createUnitVectorFromLongLat(p2);
+    const p3v3 = createUnitVectorFromLongLat(p3);
+    const arc1 = createArc(p1v3, p2v3);
+    const arc2 = createArc(p2v3, p3v3);
+    const arc3 = createArc(p3v3, p1v3);
+    const limitVec = [0, 0, 0];
+    if (calculateZLimitPoint(arc1, limitVec)) {
+        arc1.exceededLimit = [limitVec[0], limitVec[1], limitVec[2]];
+        const longlat_ = vec3ToLongLatRadians(arc1.exceededLimit);
+        console.log('Arc 1 exceeded limit at:', longlat_.map(v => (v * 180 / Math.PI).toFixed(2)), 'rad:', arc1.exceededLimit);
+    }
+    arc1.bbox = createBBox(p1, p2, arc1.exceededLimit);
+    arc1.p0LongLat = p1;
+    arc1.p1LongLat = p2;
+    if (calculateZLimitPoint(arc2, limitVec)) {
+        arc2.exceededLimit = [limitVec[0], limitVec[1], limitVec[2]];
+    }
+    arc2.bbox = createBBox(p2, p3, arc2.exceededLimit);
+    arc2.p0LongLat = p2;
+    arc2.p1LongLat = p3;
+    if (calculateZLimitPoint(arc3, limitVec)) {
+        arc3.exceededLimit = [limitVec[0], limitVec[1], limitVec[2]];
+    }
+    arc3.bbox = createBBox(p3, p1, arc3.exceededLimit);
+    arc3.p0LongLat = p3;
+    arc3.p1LongLat = p1;
+    const bbox = {
+        min: [
+            Math.min(arc1.bbox.min[0], arc2.bbox.min[0], arc3.bbox.min[0]),
+            Math.min(arc1.bbox.min[1], arc2.bbox.min[1], arc3.bbox.min[1])
+        ],
+        max: [
+            Math.max(arc1.bbox.max[0], arc2.bbox.max[0], arc3.bbox.max[0]),
+            Math.max(arc1.bbox.max[1], arc2.bbox.max[1], arc3.bbox.max[1])
+        ],
+    };
+    const meta = {
+        arcs: [arc1, arc2, arc3],
+        bbox
+    };
+    showMeta(meta);
+    meta.shellPoints = createShellPoints(meta);
+    return meta;
+}
+function showMeta(triangleMeta) {
+    for (let i = 0; i < 3; i++) {
+        const arc = triangleMeta.arcs[i];
+        console.log(`Arc ${i} from ${showLongLatRadian(arc.p0LongLat)} to ${showLongLatRadian(arc.p1LongLat)}, bbox: min(${showLongLatRadian(arc.bbox.min)}) max(${showLongLatRadian(arc.bbox.max)})`);
+        if (arc.exceededLimit) {
+            console.log(`Exceeded limit at ${showLongLatRadian(vec3ToLongLatRadians(arc.exceededLimit))}`);
+        }
+    }
+    console.log(`Triangle BBOX: min(${showLongLatRadian(triangleMeta.bbox.min)}) max(${showLongLatRadian(triangleMeta.bbox.max)})`);
+}
+/**
+ *
+ * @param triangleMeta
+ * @param zoom
+ * @param angle
+ * @param dimension false for longitude (meridian) true for latitude (parallel)
+ */
+export function getPoints(triangleMeta, angle, dimension) {
+    // console.log("getPoints called with angle:", angle * 180 / Math.PI, "dimension:", dimension ? 'latitude' : 'longitude');
+    // find which arcs are cut by plane
+    const radians = angle;
+    if (dimension) {
+        _plane.normal[0] = 0;
+        _plane.normal[1] = 0;
+        _plane.normal[2] = 1;
+        _plane.distance = Math.sin(radians);
+    }
+    else {
+        _plane.normal[0] = Math.sin(radians);
+        _plane.normal[1] = -Math.cos(radians);
+        _plane.normal[2] = 0;
+        _plane.distance = 0;
+    }
+    let result = [];
+    // Add debugging
+    let resultsFromDistinctArcs = 0;
+    for (let i = 0; i < 3; i++) {
+        const arc = triangleMeta.arcs[i];
+        const coordIndex = dimension ? 1 : 0;
+        const minCoord = arc.bbox.min[coordIndex];
+        const maxCoord = arc.bbox.max[coordIndex];
+        if (minCoord > angle || maxCoord < angle) {
+            continue; // arc is out of range
+        }
+        const count = pointsOnArc(arc, _plane, _resultPoints);
+        if (count === 1) {
+            result.push([[..._resultPoints[0]], vec3ToLongLatRadians(_resultPoints[0])]);
+        }
+        else if (count === 2) {
+            // throw new Error('Unexpected 2 cut points on arc, should be max 1'); // TODO DELETE this line later
+            result.push([[..._resultPoints[0]], vec3ToLongLatRadians(_resultPoints[0])]);
+            result.push([[..._resultPoints[1]], vec3ToLongLatRadians(_resultPoints[1])]); // TODO: this is a fix for a bug, need to investigate later
+        }
+        resultsFromDistinctArcs += 1;
+    }
+    if (resultsFromDistinctArcs === 3) {
+        result = filterDuplicate(result);
+    }
+    if (result.length !== 2 && result.length !== 4) {
+        // TODO: THERE is a case where 4 points are found.
+        // this happens when two arcs has limit and share space in Z dimension
+        console.log("ERROR");
+        const text = 'Angle:' + angle + ' dimension:' + (dimension ? 'latitude' : 'longitude') + "\n" +
+            'Result points count:' + result.length + "\n" +
+            "bbox:" + triangleMeta.bbox.min[0] * 180 / Math.PI + ", " + triangleMeta.bbox.min[1] * 180 / Math.PI + ", " + triangleMeta.bbox.max[0] * 180 / Math.PI + ", " + triangleMeta.bbox.max[1] * 180 / Math.PI + "\n";
+        showMeta(triangleMeta);
+        for (let res of result) {
+            const ll = res[1];
+            console.log("Point: " + ll[0] * 180 / Math.PI + ", " + ll[1] * 180 / Math.PI + "\n");
+        }
+        throw new Error(`Unexpected cut count for tile cut, got: ${result.length}, angle: ${angle * 180 / Math.PI}, dimension: ${dimension ? 'latitude' : 'longitude'} \n` + text);
+    }
+    // TODO: i want to see it delete later
+    if (result.length === 4) {
+        console.warn("Warning: 4 cut points found on triangle for angle:", angle * 180 / Math.PI, "dimension:", dimension ? 'latitude' : 'longitude', "points:", result);
+    }
+    result.sort((a, b) => {
+        if (dimension) {
+            return a[0][1] - b[0][1]; // sort by y for longitude cuts
+        }
+        else {
+            return a[1][0] - b[1][0]; // sort by x for latitude cuts
+        }
+    });
+    return result;
+}
+function getEdgePoints(triangleMeta) {
+    const points = [
+        triangleMeta.arcs[0].p0,
+        triangleMeta.arcs[1].p0,
+        triangleMeta.arcs[2].p0,
+    ];
+    for (let i = 0; i < 3; i++) {
+        if (triangleMeta.arcs[i].exceededLimit) {
+            points.push(triangleMeta.arcs[i].exceededLimit);
+        }
+    }
+    return points;
+}
+// TODO: EDGES NEED ! LEVEL MORE ZOOM LEVEL OF RESOLUTION as THEY CAN BE NEIGHBOURS OF HIGHER ZOOM LEVEL TILES....
+// simple strategy: get max zoom level of neighbour, add edge cuts based on that zoom level, do not fill inner points.
+// partialTessellation cure this problem automatically
+export function getAllPoints(triangleMeta, zoom, innerCuts = TILE_DEM_STEPCOUNT) {
+    // TODO: lonLengthRadian and latInnerStep might be change. Dynamic zoom level will show if needed
+    const points = [];
+    const longLatPoints = [];
+    // CALCULATE INFORMATION NEEDED FOR CUTTING
+    const tileCount = TILE_COUNTS[zoom];
+    const lonLengthRadian = 2 * Math.PI / tileCount / innerCuts; // inner step
+    const startMeridianRadian = triangleMeta.bbox.min[0];
+    const endMeridianRadian = triangleMeta.bbox.max[0];
+    const startParallelRadian = triangleMeta.bbox.min[1];
+    const endParallelRadian = triangleMeta.bbox.max[1];
+    // GET EDGE POINTS
+    const edgePoints = getEdgePoints(triangleMeta);
+    const shellPoints = triangleMeta.shellPoints;
+    for (let i = 0; i < edgePoints.length; i++) {
+        const longLat = vec3ToLongLatRadians(edgePoints[i]);
+        longLatPoints.push(...shellPoints[i]);
+        longLatPoints.push(...longLat);
+        points.push(0, 0, 0);
+        points.push(...edgePoints[i]);
+    }
+    // GET ALL PARRALLEL CUTS AND FILL MIDDLE POINTS
+    // how to calculate parallel tiles in range of bbox
+    const startTileY = latToTileY(startParallelRadian, zoom);
+    const endTileY = latToTileY(endParallelRadian, zoom);
+    const latInnerStep = 1 / innerCuts;
+    let currentY = startTileY - Math.abs(startTileY % latInnerStep);
+    if (currentY === startTileY)
+        currentY -= latInnerStep; // since start point is already added
+    let latCutCount = 0;
+    while (currentY > endTileY) {
+        const lat = tileYtoLat(currentY, zoom);
+        const concurances = getPoints(triangleMeta, lat, true);
+        for (let i = 0; i < concurances.length; i += 2) {
+            const p0 = concurances[i];
+            const p1 = concurances[i + 1];
+            points.push(...p0[0]);
+            longLatPoints.push(...p0[1]);
+            fillBetweenInParallels(lat, p0[1], p1[1], lonLengthRadian, points, longLatPoints);
+            points.push(...p1[0]);
+            longLatPoints.push(...p1[1]);
+            if (length(p0[0]) < 0.99 || length(p1[0]) < 0.99 || length(p0[0]) > 1.01 || length(p1[0]) > 1.01) {
+                console.warn("Warning: Cut point is not on unit sphere!", length(p0[0]), length(p1[0]));
+            }
+        }
+        currentY -= latInnerStep;
+        latCutCount++;
+    }
+    let currentLong = startMeridianRadian - startMeridianRadian % lonLengthRadian;
+    if (currentLong === startMeridianRadian)
+        currentLong += lonLengthRadian; // since start point is already added
+    while (currentLong < endMeridianRadian) {
+        const [p0, p1] = getPoints(triangleMeta, currentLong, false);
+        if (!isOnTileEdge(p0[1], zoom)) {
+            points.push(...p0[0]);
+            longLatPoints.push(...p0[1]);
+        }
+        if (!isOnTileEdge(p1[1], zoom)) {
+            points.push(...p1[0]);
+            longLatPoints.push(...p1[1]);
+        }
+        currentLong += lonLengthRadian;
+    }
+    const delaunator = new Delaunator(longLatPoints);
+    let indices = delaunator.triangles;
+    const edgeIndexes = shellPoints.map((e, index) => index * 2); // edge points are always first points in list
+    indices = filteroutEdgeConnections(indices, edgeIndexes);
+    // rotateIndices(indices);
+    return { vec3s: new Float32Array(points), longLats: new Float32Array(longLatPoints), indices: indices };
+}
+function fillBetweenInParallels(lat, p1, p2, step, fillVec3Arr, longLatPoints) {
+    // return;
+    // const start = Math.min(p1[0], p2[0]);
+    // const end = Math.max(p1[0], p2[0]);
+    const start = p1[0];
+    const end = p2[0];
+    // console.log("start:", start * 180 / Math.PI, "end:", end * 180 / Math.PI, "lat:", lat * 180 / Math.PI);
+    let current = start - (start % step);
+    while (current < end) {
+        const item = [current, lat];
+        fillVec3Arr.push(...createUnitVectorFromLongLat(item));
+        longLatPoints.push(...item);
+        current += step;
+    }
+}
+function filterDuplicate(points) {
+    const result = [points[0]];
+    let dublicate = false;
+    for (let i = 1; i < points.length; i++) {
+        for (let j = 0; j < result.length; j++) {
+            if (equals(points[i][0], result[j][0])) {
+                dublicate = true;
+                break;
+            }
+        }
+        if (!dublicate) {
+            result.push(points[i]);
+        }
+    }
+    return result;
+}
+function showLongLatRadian(longLat) {
+    return `(${(longLat[0] * 180 / Math.PI).toFixed(2)}°, ${(longLat[1] * 180 / Math.PI).toFixed(2)}°)`;
+}
+function rotateIndices(indices) {
+    const len = indices.length / 3;
+    let hold;
+    for (let i = 0; i < len; i++) {
+        hold = indices[i * 3];
+        indices[i * 3] = indices[i * 3 + 1];
+        indices[i * 3 + 1] = hold;
+    }
+    return indices;
+}
+// This method for removing external edge connections. The connections are unnecessary and cause a veil descending to the center of sphere from the edges
+function filteroutEdgeConnections(indexes, filterOutIndexes) {
+    const length = indexes.length / 3;
+    const result = [];
+    for (let i = 0; i < length; i++) {
+        let pass = false;
+        for (let filterIndex of filterOutIndexes) {
+            if (indexes[i * 3] === filterIndex || indexes[i * 3 + 1] === filterIndex || indexes[i * 3 + 2] === filterIndex) {
+                pass = true;
+                break;
+            }
+        }
+        if (pass)
+            continue;
+        result.push(indexes[i * 3], indexes[i * 3 + 1], indexes[i * 3 + 2]);
+    }
+    return new Uint32Array(result);
+}
+/**
+ * @unlockedPerk cache
+ * final outpout can be saved on a hashmap since this triangles are static
+ */
+function shredTriangleTessellationMeta(triangleMeta, zoomLevel) {
+    /**
+     * What if tile is covered by the curve of the limit of a single arc.
+     */
+    const result = [];
+    // cut triangleMeta into smaller triangles based on zoom level...
+    return result;
+}
+/**
+ * @lockedPerk cache
+ *
+ * cache can be applied at tile triangle intersection level;
+ *
+ * @unlockedPerk smoothZoomTransition
+ *
+ * @puzzle triangle should be covered without duplicate points. A tile can be covered by a bigger one.
+ * @solution bbox cuts:
+ *  Ax    1 x  x is higher zoom level tile, A is a tile that covers it. 1 2 3 should be asked with A zoom level.
+ *  AA ->      Problem1: 1 2 3 x will have edge points duplicated
+ *        2 3  p1 sol1: edges can be taged, or added separately by and algorithm that only adds edge poitns.
+ *
+ * still all triangles should have some sort of cached tessellation to fast render on rapit earth rotation
+ */
+/**
+ * Creates a mesh for a spherical triangle, tessellated only within the
+ * regions specified by the `limits` array.
+ *
+ * @param triangleMeta The metadata for the spherical triangle.
+ * @param limits An array of bounding boxes and their associated zoom levels to tessellate.
+ * @param innerCuts The number of subdivisions within each tile (e.g., TILE_DEM_STEPCOUNT).
+ * @returns A set of arrays (vec3s, longLats, indices) representing the partial mesh.
+ */
+export function partialTessellation(triangleMeta, limits, innerCuts) {
+    // TODO: pointMap can be local variable and cleaned after function call to avoid reinitialization overhead
+    const pointMap = new Map(); // Key: "lon|lat", Value: index
+    const allVec3s = [];
+    const allLongLats = [];
+    let pointCounter = 0;
+    /**
+     * Precision for coordinate keys in the map. 1e-12 radians is
+     * extremely small (sub-millimeter on Earth's surface) and avoids
+     * floating point inaccuracies causing duplicate points.
+     */
+    const KEY_PRECISION = 10;
+    /**
+     * Adds a point to the vertex arrays if it doesn't already exist.
+     * Returns the index of the point (new or existing).
+     */
+    const addPoint = (longLat, vec3) => {
+        const key = `${longLat[0].toPrecision(KEY_PRECISION)}|${longLat[1].toPrecision(KEY_PRECISION)}`;
+        let index = pointMap.get(key);
+        if (index !== undefined) {
+            return index; // Point already exists
+        }
+        // Point is new, add it
+        const v3 = vec3 || createUnitVectorFromLongLat(longLat);
+        allVec3s.push(...v3);
+        allLongLats.push(...longLat);
+        index = pointCounter++;
+        pointMap.set(key, index);
+        return index;
+    };
+    // 1. Add triangle's "shell" (for Delaunay) and "edge" (vertices/limits) points
+    // These points constrain the triangulation.
+    const shellPointIndices = [];
+    const edgePoints = getEdgePoints(triangleMeta);
+    // Assuming shellPoints and edgePoints have the same length and correspond
+    const shellPointCount = Math.min(triangleMeta.shellPoints.length, edgePoints.length);
+    for (let i = 0; i < shellPointCount; i++) {
+        // Add the "shell" point (for Delaunay stability)
+        shellPointIndices.push(addPoint(triangleMeta.shellPoints[i]));
+        // Add the actual "edge" point (triangle vertex or limit point)
+        addPoint(vec3ToLongLatRadians(edgePoints[i]), edgePoints[i]);
+    }
+    // 2. Iterate through each tile limit
+    for (const { bbox: tileBBox, zoom } of limits) {
+        // 2a. Calculate the intersection BBOX (the area we'll work on)
+        const workBBox = {
+            min: [
+                Math.max(triangleMeta.bbox.min[0], tileBBox.min[0]),
+                Math.max(triangleMeta.bbox.min[1], tileBBox.min[1])
+            ],
+            max: [
+                Math.min(triangleMeta.bbox.max[0], tileBBox.max[0]),
+                Math.min(triangleMeta.bbox.max[1], tileBBox.max[1])
+            ],
+        };
+        // If the intersection is invalid (no overlap), skip this tile
+        if (workBBox.min[0] >= workBBox.max[0] || workBBox.min[1] >= workBBox.max[1]) {
+            continue;
+        }
+        // 2b. Calculate grid steps for this tile's zoom
+        const tileCount = TILE_COUNTS[zoom];
+        const lonStep = (2 * Math.PI) / tileCount / innerCuts;
+        const latStep = 1.0 / innerCuts; // This is in tileY units
+        // 2c. Generate Latitude (Parallel) Points
+        const startTileY = latToTileY(workBBox.max[1], zoom); // max lat -> min tileY
+        const endTileY = latToTileY(workBBox.min[1], zoom); // min lat -> max tileY
+        let currentY = Math.ceil(startTileY / latStep) * latStep;
+        if (currentY < startTileY - 1e-9)
+            currentY += latStep; // Ensure we start inside or on edge
+        while (currentY <= endTileY + 1e-9) {
+            const lat = tileYtoLat(currentY, zoom);
+            // Skip if rounding put us slightly outside the work box
+            if (lat < workBBox.min[1] - 1e-9 || lat > workBBox.max[1] + 1e-9) {
+                currentY += latStep;
+                continue;
+            }
+            // Find where this latitude line intersects the triangle
+            const intersections = getPoints(triangleMeta, lat, true);
+            for (let i = 0; i < intersections.length; i += 2) {
+                const p0 = intersections[i]; // [Vec3, LongLatRadian]
+                const p1 = intersections[i + 1];
+                // Find the segment of this latitude line that is *inside* both
+                // the triangle (p0-p1) AND the tile BBOX (workBBox)
+                const triMinLon = Math.min(p0[1][0], p1[1][0]);
+                const triMaxLon = Math.max(p0[1][0], p1[1][0]);
+                const segMinLon = Math.max(workBBox.min[0], triMinLon);
+                const segMaxLon = Math.min(workBBox.max[0], triMaxLon);
+                // If this clipped segment is valid, generate points
+                if (segMinLon < segMaxLon - 1e-9) {
+                    // Add the exact start and end points of the clipped segment
+                    addPoint([segMinLon, lat]);
+                    addPoint([segMaxLon, lat]);
+                    // Add fill points *between* them
+                    let currentLon = Math.ceil(segMinLon / lonStep) * lonStep;
+                    if (currentLon < segMinLon - 1e-9)
+                        currentLon += lonStep;
+                    while (currentLon < segMaxLon - 1e-9) {
+                        addPoint([currentLon, lat]);
+                        currentLon += lonStep;
+                    }
+                }
+            }
+            currentY += latStep;
+        }
+        // 2d. Generate Longitude (Meridian) Points
+        const startLon = workBBox.min[0];
+        const endLon = workBBox.max[0];
+        let currentLon = Math.ceil(startLon / lonStep) * lonStep;
+        if (currentLon < startLon - 1e-9)
+            currentLon += lonStep;
+        while (currentLon <= endLon + 1e-9) {
+            // Find where this longitude line intersects the triangle
+            const intersections = getPoints(triangleMeta, currentLon, false);
+            for (const p of intersections) {
+                const pLongLat = p[1];
+                // Check if this point is inside the *workBBox*
+                if (pLongLat[1] >= workBBox.min[1] - 1e-9 &&
+                    pLongLat[1] <= workBBox.max[1] + 1e-9) {
+                    addPoint(pLongLat, p[0]);
+                }
+            }
+            currentLon += lonStep;
+        }
+    } // End loop over limits
+    // 3. Triangulate
+    // We must have at least 3 points to make a triangle
+    if (pointCounter < 3) {
+        return {
+            vec3s: new Float32Array(),
+            longLats: new Float32Array(),
+            indices: new Uint32Array(),
+        };
+    }
+    const delaunator = new Delaunator(allLongLats);
+    let indices = delaunator.triangles;
+    // 4. Filter out triangles connected to the "shell" points
+    indices = filteroutEdgeConnections(indices, shellPointIndices);
+    return {
+        vec3s: new Float32Array(allVec3s),
+        longLats: new Float32Array(allLongLats),
+        indices: indices,
+    };
+}

package/Math/tessellation/triangle-tessellation.js

@@ -0,0 +1,14 @@
+/**
+ * @author Toprak Ozturk
+ *
+ */
+import { createTriangleTessellationMeta, getAllPoints, partialTessellation } from "./triangle-tessellation-meta";
+export function test1(zoomLevel, p1, p2, p3) {
+    const triangleMeta = createTriangleTessellationMeta(p1, p2, p3);
+    const { vec3s, longLats, indices } = getAllPoints(triangleMeta, zoomLevel);
+    return { vec3s, longLats, indices };
+}
+export function partialTest(bboxZooms, p1, p2, p3) {
+    const triangleMeta = createTriangleTessellationMeta(p1, p2, p3);
+    return partialTessellation(triangleMeta, bboxZooms, 5);
+}

package/Math/tessellation/zoom-catch.js

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

package/Math/vec3.js

@@ -7,6 +7,11 @@ function set(out, x, y, z) {
     out[1] = y;
     out[2] = z;
 }
+function negate(item) {
+    item[0] = -item[0];
+    item[1] = -item[1];
+    item[2] = -item[2];
+}
 function clone(a) {
     return [a[0], a[1], a[2]];
 }
@@ -100,6 +105,14 @@ function fromLongLatToUnitVector(out, longLat) {
     out[1] = cosLat * Math.sin(longitude);
     out[2] = Math.sin(latitude);
 }
+function createUnitVectorFromLongLat(longLat) {
+    const cosLat = Math.cos(longLat[1]);
+    return [
+        cosLat * Math.cos(longLat[0]),
+        cosLat * Math.sin(longLat[0]),
+        Math.sin(longLat[1])
+    ];
+}
 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];
@@ -123,4 +136,16 @@ function randomUnit(out) {
 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, fromUnitVectorToLongLat, fromLongLatToUnitVector, applyQuaternion, randomUnit, str };
+function vec3ToLongLatDegrees(v) {
+    return [
+        Math.atan2(v[1], v[0]) * 180 / Math.PI,
+        Math.asin(v[2]) * 180 / Math.PI
+    ];
+}
+function vec3ToLongLatRadians(v) {
+    return [
+        Math.atan2(v[1], v[0]),
+        Math.asin(v[2])
+    ];
+}
+export { create, set, clone, copy, add, subtract, negate, dot, cross, multiplyScalar, divideScalar, lengthSquared, length, normalize, distanceSquared, distance, equals, fromUnitVectorToLongLat, fromLongLatToUnitVector, applyQuaternion, randomUnit, str, createUnitVectorFromLongLat, vec3ToLongLatDegrees, vec3ToLongLatRadians };