@pirireis/webglobeplugins 0.16.4 → 0.16.7

package/Math/arc.js

@@ -10,6 +10,15 @@ const _originPlane = /*@__PURE__*/ planeCreate(vec3create(0, 0, 1), 0);
 // dont change distance of _originPlane
 const _rotationQuaternion = /*@__PURE__*/ quaternionCreate();
 const _longLat = /*@__PURE__*/ [0, 0];
+// Normalize angles to [0, 2π)
+function normalizeLon(angle) {
+    while (angle < 0)
+        angle += 2 * Math.PI;
+    while (angle >= 2 * Math.PI)
+        angle -= 2 * Math.PI;
+    return angle;
+}
+;
 function create(p0, p1) {
     const normal = vec3create(0, 0, 0);
     cross(normal, p0, p1);
@@ -25,7 +34,6 @@ function create(p0, p1) {
         // Handle opposite points case
         const tempPlane = planeCreate(vec3create(), 0);
         _oppositePointsHandle(p0, p1, normal, tempPlane);
-        vec3copy(coverPlaneNormal, tempPlane.normal);
         distance = tempPlane.distance;
     }
     return {
@@ -43,6 +51,7 @@ function set(out, p0, p1) {
     vec3copy(out.p0, p0);
     vec3copy(out.p1, p1);
     cross(out.normal, p0, p1);
+    normalize(out.normal, out.normal); // ← ADD THIS LINE - normalize the normal vector!
     vec3set(_0vector, p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]);
     const ls = lengthSquared(_0vector);
     if (ls > EPSILON) {
@@ -52,6 +61,8 @@ function set(out, p0, p1) {
     else {
         _oppositePointsHandle(p0, p1, out.normal, out.coverPlane);
     }
+    // Also update coverAngle to match what create() does
+    out.coverAngle = Math.acos(dot(p0, p1));
 }
 function copy(out, a) {
     vec3copy(out.p0, a.p0);
@@ -119,6 +130,7 @@ function _oppositePointsHandle(p0, p1, outNormal, outCoverPlane) {
     }
     planeFromPoints({ normal: outNormal, distance: 0 }, p0, _0vector, p1);
     cross(outCoverPlane.normal, outNormal, p0);
+    normalize(outCoverPlane.normal, outCoverPlane.normal);
 }
 function _populatePointsWithClosestPointInsideArc(out, arc, count, closestPoint) {
     // two parts divided by closest point will be populated seperately
@@ -199,4 +211,82 @@ function _distanceSampling(out, count, inArc, cameraPosition = vec3create(0, 0,
         out[finalIndex * 2 + 1] = _longLat[1];
     }
 }
-export { create, set, copy, clone, isPointOn, equals, closestPoint, populatePoints };
+function calculateZLimitPoint(inArc, out) {
+    // The arc's plane is perpendicular to the equator, so the arc is on the equator.
+    // All points have z=0, so there's no unique z-limit point.
+    if (Math.abs(inArc.normal[2]) > 1 - EPSILON) {
+        return false;
+    }
+    // The Z-limit points of a great circle are the two points on it that are
+    // closest to the North and South poles. Their 3D coordinates can be
+    // calculated from the normal vector of the great circle's plane.
+    const nz = inArc.normal[2];
+    const n_xy_len = Math.sqrt(inArc.normal[0] * inArc.normal[0] + inArc.normal[1] * inArc.normal[1]);
+    // Candidate 1: Highest Z value (closest to North Pole)
+    const p_max_z = vec3.create(-inArc.normal[0] * nz / n_xy_len, -inArc.normal[1] * nz / n_xy_len, n_xy_len);
+    // Candidate 2: Lowest Z value (closest to South Pole)
+    const p_min_z = vec3.create(inArc.normal[0] * nz / n_xy_len, inArc.normal[1] * nz / n_xy_len, -n_xy_len);
+    // Now, we check if either of these points lie on the given arc segment.
+    // A point is on the shorter arc if its projection onto the cover plane's
+    // normal is on the positive side.
+    const d_max = dot(p_max_z, inArc.coverPlane.normal);
+    const d_min = dot(p_min_z, inArc.coverPlane.normal);
+    if (d_max >= inArc.coverPlane.distance - EPSILON) {
+        vec3.copy(out, p_max_z);
+        return true;
+    }
+    if (d_min >= inArc.coverPlane.distance - EPSILON) {
+        vec3.copy(out, p_min_z);
+        return true;
+    }
+    return false;
+}
+function doesArcPassThroughMeridian(inArc, meridians) {
+    const result = new Array(meridians.length).fill(false);
+    // Get longitude angles for p0 and p1
+    const p0Lon = Math.atan2(inArc.p0[1], inArc.p0[0]);
+    const p1Lon = Math.atan2(inArc.p1[1], inArc.p1[0]);
+    if (inArc.p0[2] >= 1 - EPSILON || inArc.p1[2] >= 1 - EPSILON) {
+        return result;
+    }
+    const p0LonNorm = normalizeLon(p0Lon);
+    const p1LonNorm = normalizeLon(p1Lon);
+    // Determine if we're taking the shorter or longer arc
+    let startLon = p0LonNorm;
+    let endLon = p1LonNorm;
+    // Calculate the angular difference both ways
+    const diff1 = normalizeLon(endLon - startLon);
+    // Take the shorter path (great circle property)
+    const takeShorterPath = diff1 <= Math.PI;
+    if (!takeShorterPath) {
+        // Swap start and end for the shorter path
+        [startLon, endLon] = [endLon, startLon];
+    }
+    for (let i = 0; i < meridians.length; i++) {
+        const meridian = normalizeLon(meridians[i]);
+        // Check if meridian is between start and end longitudes
+        if (takeShorterPath) {
+            if (startLon <= endLon) {
+                // Normal case: no wraparound
+                result[i] = meridian >= startLon && meridian <= endLon;
+            }
+            else {
+                // Wraparound case: arc crosses 0°/360°
+                result[i] = meridian >= startLon || meridian <= endLon;
+            }
+        }
+        else {
+            // Taking the longer path
+            if (startLon <= endLon) {
+                // Arc goes the long way around
+                result[i] = meridian <= startLon || meridian >= endLon;
+            }
+            else {
+                // Normal case for long path
+                result[i] = meridian >= endLon && meridian <= startLon;
+            }
+        }
+    }
+    return result;
+}
+export { create, set, copy, clone, isPointOn, equals, closestPoint, populatePoints, calculateZLimitPoint, doesArcPassThroughMeridian };

package/Math/circle-cdf-points.js

@@ -1,4 +1,4 @@
-import { RADIANS } from "./methods";
+import { RADIAN } from "./methods";
 function createCummulativeTemplate(numberOfPoints, strength, denseRatio = 0.5 // Ratio of points to be densely packed at the start.
 ) {
     // Handle edge cases for the number of points.
@@ -60,7 +60,7 @@ function globeFindPointByPolar(out, globe, centerLong, centerLat, radius, ratios
     }
 }
 function globeFindPointByPolarHalfCircle(out, globe, centerLong, centerLat, radius, rotation, ratios) {
-    const rotCentigrade = rotation / RADIANS + 720;
+    const rotCentigrade = rotation / RADIAN + 720;
     for (let i = 0; i < ratios.length; i++) {
         const point = globe.Math.FindPointByPolar(centerLong, centerLat, radius, (ratios[i] * 180 + rotCentigrade) % 360);
         out[i * 2] = point.long;

package/Math/circle.js

@@ -1,4 +1,4 @@
-import { RADIANS } from './methods';
+import { RADIAN } from './methods';
 import { subtract, normalize, dot, fromLongLatToUnitVector, copy, multiplyScalar, clone } from './vec3';
 const _0vec3 = [0, 0, 0];
 function closestAzimuthAngle(circleProperties, point) {
@@ -15,7 +15,7 @@ function closestAzimuthAngle(circleProperties, point) {
 }
 function createCircleClosestAzimuthAngleProperties(circle) {
     const normal = Array(3);
-    fromLongLatToUnitVector(normal, [circle.center[0] * RADIANS, circle.center[1] * RADIANS]);
+    fromLongLatToUnitVector(normal, [circle.center[0] * RADIAN, circle.center[1] * RADIAN]);
     const N = clone(normal);
     const distance = dot([0, 0, 1], normal);
     multiplyScalar(N, N, distance);

package/Math/juction/arc-plane.js

@@ -1,9 +1,9 @@
 import { EPSILON } from "../constants";
-import { create as vec3create, copy as vec3copy, dot, distanceSquared, } from "../vec3";
+import { create as vec3create, copy as vec3copy, dot, distanceSquared, copy, normalize } from "../vec3";
 import { create as lineCreate } from "../line";
 import { create as planeCreate, distanceToPoint, getUnitSphereRadiusAngle } from "../plane";
 import { copy as arcCopy, set as arcSet } from "../arc";
-import { planePlaneJuction } from "./plane-plane";
+import { planePlaneJunction } from "./plane-plane";
 import { lineSphereIntersection } from "./line-sphere";
 const _intersectionLine = /*@__PURE__*/ lineCreate();
 const _originPlane = /*@__PURE__*/ planeCreate();
@@ -39,9 +39,9 @@ export function arcSlice(out, inArc, junctionPlane) {
     }
     // plane-plane intersection line should be calculated for the rest of the calculations
     vec3copy(_originPlane.normal, inArc.normal);
-    const isPlaneJunctions = planePlaneJuction(_intersectionLine, _originPlane, junctionPlane);
+    const isPlaneJunctions = planePlaneJunction(_intersectionLine, _originPlane, junctionPlane);
     if (!isPlaneJunctions) { // case C: planes are parallel. 
-        if (junctionPlane.distance <= 0) {
+        if (junctionPlane.distance <= 0) { // same direction
             arcCopy(out[0], inArc);
             return 1; // No intersection
         }
@@ -53,23 +53,35 @@ export function arcSlice(out, inArc, junctionPlane) {
     // calculate the intersection points
     const isSphereIntersection = lineSphereIntersection(_intersectionPoints, _intersectionLine, _originSphere);
     if (!isSphereIntersection) {
-        // other edge caes should be covered by now
         return 0; // No intersection
     }
-    const i0IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -EPSILON;
-    const i1IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -EPSILON;
-    const p0IsVisible = distanceToPoint(junctionPlane, inArc.p0) > -EPSILON;
-    const p1IsVisible = distanceToPoint(junctionPlane, inArc.p1) > -EPSILON;
+    // ← ADD NORMALIZATION HERE
+    normalize(_intersectionPoints[0], _intersectionPoints[0]);
+    normalize(_intersectionPoints[1], _intersectionPoints[1]);
+    const i0IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > EPSILON;
+    const i1IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > EPSILON;
+    const p0IsVisible = distanceToPoint(junctionPlane, inArc.p0) > EPSILON;
+    const p1IsVisible = distanceToPoint(junctionPlane, inArc.p1) > EPSILON;
     if (!p0IsVisible && !p1IsVisible && !i0IsCovered && !i1IsCovered) {
         return 0; // No intersection
     }
     if (i0IsCovered && i1IsCovered && p0IsVisible && p1IsVisible) {
         // calculate which points are closer
+        if (dot(inArc.coverPlane.normal, junctionPlane.normal) > 1 - EPSILON) {
+            arcCopy(out[0], inArc);
+            return 1;
+        }
+        else if (dot(inArc.coverPlane.normal, junctionPlane.normal) < -1 + EPSILON) {
+            return 0;
+        }
+        // Determine which intersection point is closer to p0
         const p0i0DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[0]);
         const p0i1DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[1]);
-        const case0 = p0i0DistanceSquared < p0i1DistanceSquared;
-        arcSet(out[0], inArc.p0, case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
-        arcSet(out[1], inArc.p1, !case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
+        const closerToP0 = p0i0DistanceSquared < p0i1DistanceSquared ? 0 : 1;
+        // The visible portion is from p0 to the closer intersection point
+        arcSet(out[0], inArc.p0, _intersectionPoints[closerToP0]);
+        // The second arc goes from the farther point to p1
+        arcSet(out[1], _intersectionPoints[1 - closerToP0], inArc.p1);
         return 2;
     }
     if (i0IsCovered && i1IsCovered) {
@@ -86,3 +98,46 @@ export function arcSlice(out, inArc, junctionPlane) {
     arcSet(out[0], p0IsVisible ? inArc.p0 : inArc.p1, i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]);
     return 1;
 }
+function showArc(arc) {
+    return `Arc: p0(${arc.p0[0].toFixed(2)}, ${arc.p0[1].toFixed(2)}, ${arc.p0[2]}) - p1(${arc.p1[0]}, ${arc.p1[1].toFixed(2)}, ${arc.p1[2].toFixed(2)})`;
+}
+function showPlane(plane) {
+    return `Plane: n(${plane.normal[0].toFixed(2)}, ${plane.normal[1].toFixed(2)}, ${plane.normal[2].toFixed(2)}) d(${plane.distance.toFixed(2)})`;
+}
+export function pointsOnArc(inArc, junctionPlane, out) {
+    // case A: junction plane is too far
+    if (Math.abs(junctionPlane.distance) > 1) {
+        return 0;
+    }
+    // Calculate plane-plane intersection
+    vec3copy(_originPlane.normal, inArc.normal);
+    const isPlaneJunctions = planePlaneJunction(_intersectionLine, _originPlane, junctionPlane);
+    // case B: planes are parallel
+    if (!isPlaneJunctions) {
+        return 0;
+    }
+    // Calculate intersection points with unit sphere
+    const isSphereIntersection = lineSphereIntersection(_intersectionPoints, _intersectionLine, _originSphere);
+    // case C: intersection line does not intersect the unit sphere
+    if (!isSphereIntersection) {
+        return 0;
+    }
+    // Check which intersection points are covered by the arc
+    const i0IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -EPSILON;
+    const i1IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -EPSILON;
+    // Check which endpoints are visible
+    let count = 0;
+    // Add covered intersection points
+    if (i0IsCovered) {
+        copy(out[count], _intersectionPoints[0]);
+        count++;
+    }
+    if (Math.abs(Math.abs(junctionPlane.distance) - 1) < EPSILON) {
+        return count; // Tangent case, only one intersection point
+    }
+    if (i1IsCovered) {
+        copy(out[count], _intersectionPoints[1]);
+        count++;
+    }
+    return count;
+}

package/Math/juction/line-sphere.js

@@ -3,18 +3,18 @@ import { at } from "../line";
 const _0vector = /*@__PURE__*/ create(0, 0, 0);
 export function lineSphereIntersection(out, inLine, inSphere) {
     subtract(_0vector, inLine.origin, inSphere.center);
+    const dirLengthSq = lengthSquared(inLine.direction);
+    const dot_ = dot(_0vector, inLine.direction);
     const distanceSquared = lengthSquared(_0vector);
     const radiusSquared = inSphere.radius * inSphere.radius;
-    const dot_ = dot(_0vector, inLine.direction);
-    const dotSquared = dot_ * dot_;
-    const discriminant = dotSquared + radiusSquared - distanceSquared;
+    const discriminant = dot_ * dot_ - dirLengthSq * (distanceSquared - radiusSquared);
     if (discriminant < 0) {
         return false; // no intersection
     }
     else {
-        const a = Math.sqrt(discriminant);
-        const t1 = -dot_ - a;
-        const t2 = -dot_ + a;
+        const sqrtDiscriminant = Math.sqrt(discriminant);
+        const t1 = (-dot_ - sqrtDiscriminant) / dirLengthSq;
+        const t2 = (-dot_ + sqrtDiscriminant) / dirLengthSq;
         at(out[0], inLine, t1);
         at(out[1], inLine, t2);
         return true;

package/Math/juction/plane-plane.js

@@ -1,10 +1,8 @@
 import { EPSILON } from "../constants";
-import { copy, create, dot, cross, lengthSquared } from "../vec3";
-const _normal1 = create();
-const _normal2 = create();
-export function planePlaneJuction(out, plane1, plane2) {
-    copy(_normal1, plane1.normal);
-    copy(_normal2, plane2.normal);
+import { dot, cross, lengthSquared } from "../vec3";
+export function planePlaneJunction(out, plane1, plane2) {
+    const _normal1 = plane1.normal;
+    const _normal2 = plane2.normal;
     const distance1 = plane1.distance;
     const distance2 = plane2.distance;
     const { origin, direction } = out;

package/Math/methods.js

@@ -1,6 +1,6 @@
 import { WORLD_RADIUS_3D, WORLD_RADIUS_MERCATOR } from './constants';
 import { dot as dot3, copy as copy3 } from './vec3';
-export const RADIANS = Math.PI / 180;
+export const RADIAN = Math.PI / 180;
 const _0vec3 = [0, 0, 0];
 const _0vec2 = [0, 0];
 export const cartesian3dToRadian = (output, cartesian) => {
@@ -47,8 +47,8 @@ export const sphericalLinearInterpolation_Cartesian3d = (output, a, b, ratio) =>
     output[2] = _0vec3[2] * height;
 };
 export const wgs84ToCartesian3d = (output, long, lat, height) => {
-    const longRad = long * RADIANS;
-    const latRad = lat * RADIANS;
+    const longRad = long * RADIAN;
+    const latRad = lat * RADIAN;
     const x = Math.cos(latRad) * Math.cos(longRad);
     const y = Math.cos(latRad) * Math.sin(longRad);
     const z = Math.sin(latRad);
@@ -59,8 +59,8 @@ export const wgs84ToCartesian3d = (output, long, lat, height) => {
 };
 export const wgs84ToMercator = (long, lat) => {
     return [
-        WORLD_RADIUS_MERCATOR * long * RADIANS,
-        WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIANS / 2))
+        WORLD_RADIUS_MERCATOR * long * RADIAN,
+        WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIAN / 2))
     ];
 };
 export const pixelXYToRadians = (pixelXY) => {

package/Math/templete-shapes/grid-visually-equal.js

@@ -41,7 +41,6 @@ export function createfillGrid(globe, origin, startX, startY, rowSize, columnSiz
         grid[startY][i] = [long, lat];
     }
     // fill single horizontal from origin from startY to 0
-    console.log("grid", grid);
     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);

package/Math/tessellation/earcut/adapters.js

@@ -0,0 +1,37 @@
+function geoJSONToEarcut(geojson) {
+    const vertices = [];
+    const holes = [];
+    const dimensions = 2; // Assuming 2D coordinates (longitude, latitude)
+    let holeIndex = 0;
+    if (geojson.type !== 'FeatureCollection') {
+        throw new Error('Invalid GeoJSON: Expected FeatureCollection');
+    }
+    const features = geojson.features;
+    function processPolygon(coordinates) {
+        for (let i = 0; i < coordinates.length; i++) {
+            if (i > 0) {
+                holeIndex += coordinates[i - 1].length;
+                holes.push(holeIndex);
+            }
+            for (const coord of coordinates[i]) {
+                vertices.push(coord[0], coord[1]);
+            }
+        }
+    }
+    function processMultiPolygon(coordinates) {
+        for (const polygon of coordinates) {
+            processPolygon(polygon);
+        }
+    }
+    for (const feature of features) {
+        const geometry = feature.geometry;
+        if (geometry.type === 'Polygon') {
+            processPolygon(geometry.coordinates);
+        }
+        else if (geometry.type === 'MultiPolygon') {
+            processMultiPolygon(geometry.coordinates);
+        }
+    }
+    return { vertices, holes, dimensions };
+}
+export { geoJSONToEarcut };

package/Math/tessellation/methods.js

@@ -0,0 +1,46 @@
+import { TILE_COUNTS } from "./zoom-catch";
+/**
+ * If the slope is not close the zero not very important but
+ * If a line goes along a parallel its latitude can tilt a lot
+ * For these cases:
+ * Meridian junctions should be first.
+ * So we have information about possible edge latitude
+ * Or the counting box should be calculated accourding to great circle
+ *
+ *
+ */
+export function latToTileY(lat, zoom) {
+    return (1 - Math.log(Math.tan(lat) + 1 / Math.cos(lat)) / Math.PI) / 2 * TILE_COUNTS[zoom];
+}
+export function lonToTileX(lon, zoom) {
+    return (lon + Math.PI) / (2 * Math.PI) * TILE_COUNTS[zoom];
+}
+export function longLatToTileDecimal(lon, lat, zoom) {
+    return [lonToTileX(lon, zoom), latToTileY(lat, zoom)];
+}
+export function tileYtoLat(y, zoom) {
+    const n = Math.PI - 2 * Math.PI * y / TILE_COUNTS[zoom];
+    return (Math.PI / Math.PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n))));
+}
+export function tileXtoLon(x, zoom) {
+    return x / TILE_COUNTS[zoom] * (2 * Math.PI) - Math.PI;
+}
+export function tessellationLatDimention(zoom, lowLat, highLat) {
+    const lowY = latToTileY(lowLat, zoom);
+    const highY = latToTileY(highLat, zoom);
+    const latitudes = [];
+    if (lowY % 1 !== 0)
+        latitudes.push(lowLat);
+    for (let y = Math.ceil(lowY); y <= Math.floor(highY); y++) {
+        latitudes.push(tileYtoLat(y, zoom));
+    }
+    if (highY % 1 !== 0)
+        latitudes.push(highLat);
+    return latitudes;
+}
+export function isOnTileEdge(longLat, zoom) {
+    const tileX = lonToTileX(longLat[0], zoom);
+    const tileY = latToTileY(longLat[1], zoom);
+    const epsilon = 1 / TILE_COUNTS[zoom] / 200;
+    return (Math.abs(tileX % 1) < epsilon || Math.abs(tileY % 1) < epsilon || Math.abs(tileX % 1 - 1) < epsilon || Math.abs(tileY % 1 - 1) < epsilon);
+}

package/Math/tessellation/shred-input.js

@@ -0,0 +1,18 @@
+import earcut from "earcut";
+import { createTriangleTessellationMeta } from "./triangle-tessellation-meta";
+function shredInput(vertices, holes, zoomLevel) {
+    const result = [];
+    const triangles = earcut(vertices, holes, 2);
+    for (let i = 0; i < triangles.length; i += 3) {
+        const idx1 = triangles[i] * 2;
+        const idx2 = triangles[i + 1] * 2;
+        const idx3 = triangles[i + 2] * 2;
+        const p1 = [vertices[idx1], vertices[idx1 + 1]];
+        const p2 = [vertices[idx2], vertices[idx2 + 1]];
+        const p3 = [vertices[idx3], vertices[idx3 + 1]];
+        const triangleMeta = createTriangleTessellationMeta(p1, p2, p3);
+        result.push(triangleMeta);
+    }
+    // cut triangles into smaller pieces based on zoom level...
+    return result;
+}

package/Math/tessellation/tessellation-algorithm.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * @input
+ * A series of points defining a polygon
+ * @output
+ * A series of triangles that fill the polygon
+ *
+ * @steps
+ * @1. cut
+ * @2. sort
+ * @3. connect
+ *
+ * @cut
+ * @1. find tile cuts on the arcs, tag: enum vertex {pillar, corner},
+ * @2. find inner cuts on the arcs
+ *
+ * @sorter
+ * sort by
+ * @1 y coordinate, then x coordinate
+ * @2
+ *
+ *
+ * @connect
+ *
+ * 1. Pick two rows from the top
+ * 2. Go left to right
+ * 3. Compeare x values to connect point closest to it
+ *
+ * @smartConnect
+ *
+ * if hit from left to right, take a break
+ * if hit a concave edge, fonnect all the points until jump over to the following point of the concave
+ *
+ * that way I can calculate polygons with holes
+ *
+ * That raises a division
+ *
+ * instead of dividing into triangles
+ * divide into convex polygons
+ *
+ * convex save points and zoom level of convex shape.
+ * populate middle points when on zoom level increase
+ *
+ * @Future
+ *
+ * 1. cut is ready.
+ * WEBMercator(DEM data) to globe:
+ *   cutting with tileXY coordinates base and convert back to longlat and vector3
+ *   solves
+ * 2. connect looks promising. Can run on triangle approach as well
+ *
+ * Solving a polygon
+ *   in a single shot
+ *   without dividing into triangles
+ *   takes all the arcs to be cut in single go.
+ *   To continue following questions arise:
+ *   how to match points in a row?
+ *    Cut arcs in two if they have Z limits
+ *    cut by parallel lines,
+ *    sort by x
+ *    if 2
+ *   How to handle points in between rows?
+ *
+ *
+ */
+class PartialTesselation {
+}

package/Math/tessellation/tiler.js

@@ -0,0 +1,50 @@
+"use strict";
+// /**
+//  * Find length in x and y for a tile in given zoom level (in wgs84)
+//  * Find tile cuts for given line represented by two points
+//  * Find inner position of point in tile
+//  * 
+//  */
+// import { LongLat } from "../../types";
+// export function tileLength(zoom: number): LongLat {
+//     const tileSize = 256; // in pixels
+//     const worldSize = tileSize * Math.pow(2, zoom);
+//     const latLength = 180 / worldSize;
+//     const lonLength = 360 / worldSize;
+//     return [lonLength, latLength];
+// }
+// // export function tileCuts(p1: LongLat, p2: LongLat, zoom: number): LongLat[] {
+// //     const cuts: LongLat[] = [];
+// //     const tileSize = 256;
+// //     const worldSize = tileSize * Math.pow(2, zoom);
+// //     const latLength = 180 / worldSize;
+// //     const lonLength = 360 / worldSize;
+// //     const x1 = (p1[0] + 180) / lonLength;
+// //     const y1 = (90 - p1[1]) / latLength;
+// //     const x2 = (p2[0] + 180) / lonLength;
+// //     const y2 = (90 - p2[1]) / latLength;
+// //     const dx = x2 - x1;
+// //     const dy = y2 - y1;
+// //     const steps = Math.max(Math.abs(dx), Math.abs(dy));
+// //     const xStep = dx / steps;
+// //     const yStep = dy / steps;
+// //     let x = x1;
+// //     let y = y1;
+// //     for (let i = 0; i <= steps; i++) {
+// //         const tileX = Math.floor(x);
+// //         const tileY = Math.floor(y);
+// //         const cutX = tileX * lonLength - 180;
+// //         const cutY = 90 - tileY * latLength;
+// //         const cut: LongLat = [cutX, cutY];
+// //         if (cuts.length === 0 || (cuts[cuts.length - 1][0] !== cut[0] || cuts[cuts.length - 1][1] !== cut[1])) {
+// //             cuts.push(cut);
+// //         }
+// //         x += xStep;
+// //         y += yStep;
+// //     } 
+// //     return cuts;
+// // }
+// // function fillTriangle(p1: LongLat, p2: LongLat, p3: LongLat, zoom: number): {positions:LongLat[], indices:number[]} {
+// //     // this function fills the triangle triangle iteratively
+// //     // 
+// // }