@pirireis/webglobeplugins 0.9.9 → 0.9.10

package/util/shaderfunctions/geometrytransformations.js

@@ -0,0 +1,340 @@
+"use strict";
+// Z in kolometers
+// 
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circleOnSphere = exports.circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate = exports.circleLimpFromLongLatRadCenterMercatorCompass_accurate = exports.circleLimpFromLongLatRadCenterCartesian3D_accurate = exports.slerp = exports.realDistanceOnSphereR1 = exports.circleCircumferenceInterPolationOf2PointsRadian = exports.angleBetweenTwoPointsRadian = exports.cartesianToSpherical = exports.circleLimpFromLongLatRadCenterMercatorCompass = exports.circleLimpFromLongLatRadCenterMercatorRealDistancePadding = exports.circleLimpFromLongLatRadCenterMercatorRealDistance = exports.circleLimpFromLongLatRadCenterMercatorRealDistanceNew = exports.circleLimpFromLongLatRadCenterCartesian3D = exports.longLatRadToCartesian3DWithR = exports.longLatRadToCartesian3D = exports.longLatRadToMercator = exports.cartesian3DToGLPosition = exports.mercatorXYToGLPosition = exports.pixelXYToCartesian2DPoint = exports.pixelXYToCartesian3DPoint = exports.R_3D = exports.POLE_BY_PI = exports.PI = exports.R = exports.POLE = void 0;
+exports.POLE = `
+#ifndef POLE
+#define POLE 20037508.34
+#endif
+`;
+exports.R = `
+#ifndef R
+#define R 6378137.0
+#endif
+`;
+exports.PI = `
+#ifndef PI
+#define PI 3.141592653589793
+
+#endif
+`;
+exports.POLE_BY_PI = ` 
+#ifndef POLE_BY_PI
+#define POLE_BY_PI 6378137.0
+#endif
+`;
+exports.R_3D = `
+#ifndef R_3D
+#define R_3D 6378.137
+#endif
+`;
+exports.pixelXYToCartesian3DPoint = exports.R_3D + exports.PI + `
+vec3 pixelXYToCartesian3DPoint( vec3 position) {
+    float longRad = PI * (2.0 * position.x - 1.0);
+    float latRad = PI *  position.y;
+    float radius = R_3D + position.z;
+    float x = radius * sin(latRad) * cos(longRad);
+    float y = radius * sin(latRad) * sin(longRad);
+    float z = radius * cos(latRad);
+    return vec3(x, y, z);
+}
+`;
+exports.pixelXYToCartesian2DPoint = exports.PI + exports.POLE + exports.POLE_BY_PI + `
+vec2 pixelXYToCartesian2DPoint( vec2 position, vec2 translate, vec2 mapWH, vec2 screenWH) {
+    float x = (2.0 * position.x - 1.0) * POLE;
+    x = ((x - translate.x) / mapWH.x) * screenWH.x;    
+    float y = log( tan( ( 1.0 - position.y ) * PI / 2.0  ) ) * POLE_BY_PI;
+    y = (1.0 - (y - translate.y) / mapWH.y) * screenWH.y;
+    return  vec2(x, y);
+}
+`;
+// TODO: rename it to mercatorXYToGLPosition
+exports.mercatorXYToGLPosition = `
+vec4 mercatorXYToGLPosition( vec2 position) { // projection, translate, mapWH, screenWH comes from camera uniform block
+    float x = (( position.x - translate.x ) / mapWH.x) * screenWH.x;
+    float y = (1.0 - (position.y - translate.y) / mapWH.y) * screenWH.y;
+    return projection * vec4(x, y, 0.0, 1.0);
+} 
+`;
+exports.cartesian3DToGLPosition = `
+vec4 cartesian3DToGLPosition( vec3 position) {
+    return projection * view * vec4(position - translate, 1.0);
+}
+`;
+// pi / pole = 2 / R
+exports.longLatRadToMercator = exports.R + exports.PI + `
+vec2 longLatRadToMercator( vec2 longLatRad) {
+    float x = R * longLatRad.x;
+    float y = R * log( tan( PI / 4.0 + longLatRad.y / 2.0 ) );
+    y -= mix(-60.0, 60.0, abs(longLatRad.y + PI / 8.0) / (PI / 4.0));
+    return vec2(x, y);
+}
+`;
+exports.longLatRadToCartesian3D = exports.R_3D + `
+vec3 longLatRadToCartesian3D( vec2 longLat) {
+    float x = R_3D * cos(longLat.y) * cos(longLat.x);
+    float y = R_3D * cos(longLat.y) * sin(longLat.x);
+    float z = R_3D * sin(longLat.y);
+    return vec3(x, y, z);
+}
+`;
+exports.longLatRadToCartesian3DWithR = `
+vec3 longLatRadToCartesian3DWithR( vec2 longLat, float radius) {
+    float x = radius * cos(longLat.y) * cos(longLat.x);
+    float y = radius * cos(longLat.y) * sin(longLat.x);
+    float z = radius * sin(longLat.y);
+    return vec3(x, y, z);
+}
+`;
+// TODO: Make it precise. It doesnt use haversine formula. If this changes, change the formmula which calculates text position. 
+exports.circleLimpFromLongLatRadCenterCartesian3D = exports.R + `
+vec3 circleLimpFromLongLatRadCenterCartesian3D( vec2 center, float radius, float angle) {
+    vec3 geoW = longLatRadToCartesian3D(center);
+    vec3 normal = normalize(geoW);
+    vec3 tangent1 = cross(normal, vec3(0.0, 0.0, -1.0));
+    if ( length(tangent1) < 0.1 ){ tangent1 = cross(normal, vec3(0.0, -1.0, 0.0)); }
+    tangent1 = normalize(tangent1);
+    // rotate tangent with given angle
+    tangent1 =  cos(angle) * tangent1 - sin(angle) * cross(normal, tangent1);
+    float radius_in_angle = radius/R;
+    float projected_radius = sin(radius_in_angle) * R / 1000.0;
+    return (geoW * cos(radius_in_angle))+ tangent1 * projected_radius;
+    }
+`;
+// TODO: Make it precise. Y axis is not correct.
+exports.circleLimpFromLongLatRadCenterMercatorRealDistanceNew = exports.PI + `
+vec2 circleLimpFromLongLatRadCenterMercatorRealDistance(vec2 center, float radius, float angle) {
+    float ang = angle + PI / 2.0; // Shift angle to align with +x axis
+    float r = radius / R;
+    float cos_r = cos(r);
+    float sin_r = sin(r);
+
+    float sin_lat = sin(center.y) * cos_r + cos(center.y) * sin_r * cos(ang);
+    float lat = asin(sin_lat);
+
+    float delta_long = atan(sin(ang) * sin_r * cos(center.y), cos_r - sin(center.y) * sin_lat);
+    float longi = center.x + delta_long;
+    
+
+    return vec2(
+        R * longi,
+        R * log(tan(PI / 4.0 + lat / 2.0)) 
+    );
+}`;
+exports.circleLimpFromLongLatRadCenterMercatorRealDistance = exports.PI + `
+vec2 circleLimpFromLongLatRadCenterMercatorRealDistance(vec2 center, float radius, float angle){
+    float ang = angle + PI / 2.0; // this is there because the other methods are implemented in, angle 0 is +x axis orientatation
+    float r = radius / R;
+    float sin_lat = sin(center.y) * cos(r) + cos(center.y) * sin(r) * cos(ang);
+    float lat = asin(sin_lat);
+    float longi = center.x + atan(sin(ang) * sin(r) * cos(center.y), cos(r) - sin(center.y) * sin_lat);
+    return longLatRadToMercator(vec2(longi, lat));
+}
+`;
+// TODO: reconstruct this function
+exports.circleLimpFromLongLatRadCenterMercatorRealDistancePadding = `
+vec2 circleLimpFromLongLatRadCenterMercatorRealDistancePadding(vec2 center, float radius, float angle){
+    float radius_radian = radius / R;
+    float new_angle;
+    if (angle != - 1.5707963267948966192313216916398) {
+        float section = floor(angle / (PI / 2.0)) + 1.0;
+        float lat = center.y - radius_radian * sin(angle);
+        float scale = 1.0 / abs(cos(lat));
+        new_angle = atan(tan(angle) * scale);
+        if (section == 2.0) {
+            new_angle = mod(new_angle, PI);
+        } else if (section == 3.0) {
+            new_angle = new_angle + PI;
+        }
+    } else {
+        new_angle = angle;
+    }
+    float new_lat = center.y - radius_radian * sin(new_angle);
+    float new_scale = 1.0 / abs(cos(new_lat));
+
+    vec2 center_ = longLatRadToMercator(center);
+    float x = center_.x + new_scale * radius * cos(new_angle);
+    float y = center_.y - new_scale * radius * sin(new_angle);
+    return vec2(x, y);
+}
+`;
+exports.circleLimpFromLongLatRadCenterMercatorCompass = `
+vec2 circleLimpFromLongLatRadCenterMercatorCompass(vec2 center, float radius, float angle){
+    vec2 center_ = longLatRadToMercator(center);
+    float y = -sin(angle) * radius + center_.y;
+    float x = cos(angle) * radius + center_.x;
+    return vec2(x, y);
+} `;
+// Function to convert Cartesian coordinates back to spherical (latitude, longitude)
+exports.cartesianToSpherical = `
+vec2 cartesianToSpherical(vec3 point) {
+    float lat = degrees(asin(point.z));             // Latitude
+    float lon = degrees(atan(point.y, point.x));    // Longitude
+
+    return vec2(lat, lon);
+} `;
+// Main function to calculate an intermediate point
+exports.angleBetweenTwoPointsRadian = `
+float angleBetweenTwoPointsRadian(vec2 start_, vec2 end_) {
+    float start_lat = log(tan((1.0 - start_.y) * PI / 2.0));
+    float end_lat = log(tan((1.0 - end_.y) * PI / 2.0));
+    float angle = atan((end_lat - start_lat) / (end_.x - start_.x));
+    return angle;
+}
+`;
+exports.circleCircumferenceInterPolationOf2PointsRadian = `
+float circleCircumferenceInterPolationOf2PointsRadian(vec2 center, vec2 target, float bearing_angle, float ratio) {
+    vec2 t = target - center;
+    float mainAngle = atan(t.x, t.y);
+    float angle = mainAngle -  * ratio;
+    return angle;
+}
+`;
+exports.realDistanceOnSphereR1 = `
+float realDistanceOnSphereR1(vec2 longLat1, vec2 longLat2) {
+    float dLat = longLat2.y - longLat1.y;
+    float dLong = longLat2.x - longLat1.x;
+    float a = sin(dLat / 2.0) * sin(dLat / 2.0) + cos(longLat1.y) * cos(longLat2.y) * sin(dLong / 2.0) * sin(dLong / 2.0);
+    float c = 2.0 * atan(sqrt(a), sqrt(1.0 - a));
+    return c;
+}
+`;
+const pointsOnSphereBetween = `
+vec3 pointsOnSphereBetween(vec3 a, vec3 b, float ratio) {
+    // Normalize the input points to ensure they are on the unit sphere
+    a = normalize(a);
+    b = normalize(b);
+
+    // Compute the dot product and clamp it to avoid numerical issues
+    // float dotProduct = clamp(dot(a, b), -1.0, 1.0);
+
+    // Compute the angle between the points
+    float theta = acos(dot(a, b));
+
+    // Handle the edge case where the points are nearly identical
+    if (theta < 0.0001) {
+        return normalize(mix(a, b, ratio)); // Linear interpolation as fallback
+    }
+
+    // Compute the interpolated point using spherical linear interpolation (slerp)
+    float sinTheta = sin(theta);
+    float factorA = sin((1.0 - ratio) * theta) / sinTheta;
+    float factorB = sin(ratio * theta) / sinTheta;
+
+    vec3 result = factorA * a + factorB * b;
+
+    // Return the normalized result to ensure it lies on the sphere
+    return normalize(result);
+}`;
+const slerp = `
+${pointsOnSphereBetween}
+vec3 slerp(vec3 A, vec3 B, float t) {
+    return pointsOnSphereBetween(A, B, t) * mix(length(A), length(B), t);
+}
+`;
+exports.slerp = slerp;
+const circleLimpFromLongLatRadCenterCartesian3D_accurate = exports.R + `
+vec3 circleLimpFromLongLatRadCenterCartesian3D_accurate( vec3 geoW, float radius, float angle) {
+    vec3 normal = normalize(geoW);
+    vec3 tangent1 = cross(normal, vec3(0.0, 0.0, -1.0));
+    if ( length(tangent1) < 0.1 ){ tangent1 = cross(normal, vec3(0.0, -1.0, 0.0)); }
+    tangent1 = normalize(tangent1);
+    // rotate tangent with given angle
+    tangent1 =  cos(angle) * tangent1 - sin(angle) * cross(normal, tangent1);
+    float radius_in_angle = radius/R;
+    float projected_radius = sin(radius_in_angle) * R / 1000.0;
+    return (geoW * cos(radius_in_angle)) + tangent1 * projected_radius;
+}`;
+exports.circleLimpFromLongLatRadCenterCartesian3D_accurate = circleLimpFromLongLatRadCenterCartesian3D_accurate;
+const circleOnSphere = `
+vec3 rotateVectorAroundAxis(vec3 v, vec3 axis, float angle) {
+    float c = cos(angle);
+    float s = sin(angle);
+    float t = 1.0 - c;
+    vec3 normalizedAxis = normalize(axis); // Ensure axis is unit length
+
+    return vec3(
+        (t * normalizedAxis.x * normalizedAxis.x + c) * v.x +
+        (t * normalizedAxis.x * normalizedAxis.y - s * normalizedAxis.z) * v.y +
+        (t * normalizedAxis.x * normalizedAxis.z + s * normalizedAxis.y) * v.z,
+
+        (t * normalizedAxis.x * normalizedAxis.y + s * normalizedAxis.z) * v.x +
+        (t * normalizedAxis.y * normalizedAxis.y + c) * v.y +
+        (t * normalizedAxis.y * normalizedAxis.z - s * normalizedAxis.x) * v.z,
+
+        (t * normalizedAxis.x * normalizedAxis.z - s * normalizedAxis.y) * v.x +
+        (t * normalizedAxis.y * normalizedAxis.z + s * normalizedAxis.x) * v.y +
+        (t * normalizedAxis.z * normalizedAxis.z + c) * v.z
+    );
+
+    // Alternative, more compact way using cross and dot products:
+    // vec3 crossProd = cross(normalizedAxis, v);
+    // float dotProd = dot(normalizedAxis, v);
+    // return v * c + crossProd * s + normalizedAxis * dotProd * t;
+}
+
+/**
+ * @brief Calculates a point on a circle drawn on the surface of a sphere.
+ * The sphere is assumed to be centered at the origin (0,0,0).
+ * The circle's center on the sphere surface is M, and H is a starting point on the circle.
+ * The function returns the point obtained by rotating H around the axis defined by M by angle A.
+ *
+ * @param M The center point of the circle on the sphere's surface. The vector from the origin to M defines the rotation axis.
+ * @param H A starting point on the circle (also on the sphere's surface).
+ * @param A The angle of rotation in radians. Use radians(degrees) if your input is in degrees.
+ * @return A vec3 representing the calculated point on the sphere's surface.
+ */
+vec3 circleOnSphere(vec3 M, vec3 H, float A) {
+    // The rotation axis is the vector from the origin to the circle's center point M on the sphere.
+    // This axis vector needs to be normalized for the rotation formula.
+    vec3 rotationAxis = normalize(M);
+
+    // Rotate the starting point H around the rotation axis by angle A.
+    vec3 rotatedPoint = rotateVectorAroundAxis(H, rotationAxis, A);
+
+    // Optional but recommended: Re-normalize the result to ensure it stays exactly on the sphere's surface,
+    // counteracting potential floating-point inaccuracies, especially if the original sphere radius was 1.
+    // If the sphere has a different radius R, you might want to normalize and multiply by R:
+    // float radius = length(M); // Assuming M is exactly on the surface
+    // return normalize(rotatedPoint) * radius;
+    // If it's a unit sphere:
+    // return normalize(rotatedPoint);
+
+    // For simplicity, returning the direct result of rotation. Assume M and H were perfectly on the sphere.
+    return rotatedPoint;
+}`;
+exports.circleOnSphere = circleOnSphere;
+const circleLimpFromLongLatRadCenterMercatorCompass_accurate = `
+vec2 circleLimpFromLongLatRadCenterMercatorCompass_accurate(vec2 center, float radius, float angle){
+    float y = -sin(angle) * radius + center.y;
+    float x = cos(angle) * radius + center.x;
+    return vec2(x, y);
+} `;
+exports.circleLimpFromLongLatRadCenterMercatorCompass_accurate = circleLimpFromLongLatRadCenterMercatorCompass_accurate;
+//TODO make it work...
+const circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate = exports.PI + `
+vec2 circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate(vec2 mercator_center, float radius, float angle) {
+    vec2 center = vec2(mercator_center.x /6378137.0 , asin(tanh(mercator_center.y / 6378137.0 )));
+    float ang = angle + PI / 2.0; // Shift angle to align with +x axis
+    float r = radius / R;
+    float cos_r = cos(r);
+    float sin_r = sin(r);
+
+    float sin_lat = sin(center.y) * cos_r + cos(center.y) * sin_r * cos(ang);
+    float lat = asin(sin_lat);
+
+    float delta_long = atan(sin(ang) * sin_r * cos(center.y), cos_r - sin(center.y) * sin_lat);
+    float longi = center.x + delta_long;
+    // float y = mix(-80.5, 80.5, abs(center.y + PI / 2.0));
+    vec2 limp = vec2(
+        R * longi,
+        R * log(tan(PI / 4.0 + lat / 2.0))
+    );
+    vec2 center_mercator = vec2(
+        R * center.x,
+        R * log(tan(PI/4.0+ center.y / 2.0))
+    );
+    return mercator_center - center_mercator + limp;
+}`;
+exports.circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate = circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate;

package/util/shaderfunctions/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./geometrytransformations"), exports);
+__exportStar(require("./nodata"), exports);

package/util/shaderfunctions/nodata.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vertexIDtoTextureCoordinate = void 0;
+const vertexIDtoTextureCoordinate = `
+vec2 vertexIDtoTextureCoordinate(float id, vec2 textureDimentions) {
+    float x = mod(id, textureDimentions.x);
+    float y = floor(id / textureDimentions.x);
+    return vec2( x / textureDimentions.x, y / textureDimentions.y);
+}
+`;
+exports.vertexIDtoTextureCoordinate = vertexIDtoTextureCoordinate;

package/util/shaderfunctions/noisefunctions.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const permute34 = `` `vec3 permute34(vec3 x) {
+    x = ((x * 34.0) + 1.0) * x;
+    return x - floor(x * (1.0 / 289.0)) * 289.0;
+}` ``;
+const waveNoice = `` `float waveNoice(vec2 v)
+{
+    const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439); 
+
+	  vec2 i = floor(v + dot(v, C.yy));
+	  vec2 x0 = v - i + dot(i, C.xx);
+
+	  vec2 i1;
+    i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+
+	  vec4 x12 = x0.xyxy + C.xxzz;
+    x12.xy -= i1;
+
+    i = i - floor(i * (1.0 / 289.0)) * 289.0;
+
+	  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))
+        + i.x + vec3(0.0, i1.x, 1.0));
+
+	  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
+    m = m * m;
+    m = m * m;
+
+	  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+	  vec3 h = abs(x) - 0.5;
+	  vec3 ox = floor(x + 0.5);
+	  vec3 a0 = x - ox;
+
+    m *= inversesqrt(a0 * a0 + h * h);
+
+	  vec3 g;
+    g.x = a0.x * x0.x + h.x * x0.y;
+    g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+    return 130.0 * dot(m, g);
+}` ``;
+exports.default = {
+    permute34, waveNoice
+};

package/util/surface-line-data/arc-bboxes.js

@@ -0,0 +1,25 @@
+"use strict";
+// function naiveBBox(a: number[], b: number[]): BBox {
+//     return {
+//         minX: Math.min(a[0], b[0]),
+//         minY: Math.min(a[1], b[1]),
+//         maxX: Math.max(a[0], b[0]),
+//         maxY: Math.max(a[1], b[1])
+//     };
+// }
+// function slerp(a: Vector, b: Vector, t: number, theta: number, sinTheta: number): Vector {
+// }
+// function getArcBBoxes(arc: Arc, dotStep: number = 0.025): BBox[] {
+//     const start = arc.start;
+//     const end = arc.end;
+//     const a = [start[0], start[1], start[2]];
+//     const b = [end[0], end[1], end[2]];
+//     const theta = Math.acos(a[0] * b[0] + a[1] * b[1] + a[2] * b[2]);
+//     const step = dotStep / theta;
+//     if (step >= 1) {
+//         return [naiveBBox(start, end)];
+//     }
+//     let points = [start] as Vector[];
+//     let currentStep =
+//     return bbox;
+// }

package/util/surface-line-data/arcs-to-cuts.js

@@ -0,0 +1,50 @@
+"use strict";
+class ArcsToCutsManager {
+    constructor(rbush, { dotDistanceOfArcCuts = 0.01 }) {
+        this._map = new Map();
+        this._dotDistanceOfArcCuts = dotDistanceOfArcCuts;
+        this._rbush = rbush;
+    }
+    insertArcs(arc) {
+        if (this._map.has(arc.id)) {
+            this._deleteCuts(arc.id);
+        }
+    }
+    _deleteCuts(id) {
+        const cuts = this._map.get(id);
+        if (cuts) {
+            cuts.forEach(cut => cut.remove());
+        }
+    }
+    _cutArcAndAddToRBush(arc) {
+        const cuts = this._cutArcToBBoxs(arc);
+        cuts.forEach(cut => {
+            this._rbush.insert(cut);
+        });
+        this._map.set(arc.id, cuts);
+    }
+    _cutArcToBBoxs(arc) {
+        const cuts = [];
+        // Calculate the bounding box of the arc
+        // Create a cut object and add it to the cuts array
+        const cut = {
+            minX: bbox.minX,
+            minY: bbox.minY,
+            maxX: bbox.maxX,
+            maxY: bbox.maxY,
+            arcId: arc.id,
+        };
+        cuts.push(cut);
+        return cuts;
+    }
+}
+function sphericalLinearInterpolation(phi1, lambda1, phi2, lambda2, t) {
+    // Spherical linear interpolation between two points on a sphere
+    // Args: phi1, lambda1: starting point (in radians)
+    //       phi2, lambda2: ending point (in radians)
+    //       t: interpolation parameter (0 <= t <= 1)
+    // Returns: [phi, lambda] in radians
+    const phi = phi1 + t * (phi2 - phi1);
+    const lambda = lambda1 + t * (lambda2 - lambda1);
+    return [phi, lambda];
+}

package/util/surface-line-data/cut-arc.js

@@ -0,0 +1 @@
+"use strict";

package/util/surface-line-data/flow.js

@@ -0,0 +1,28 @@
+"use strict";
+// class FlowManager {
+//     _populateCount: number;
+//     _rbush: RBush<any>;
+//     _arcToCutsManager: ArcToCutsManager;
+//     consturctor({ populateCount = 36, dotDistanceOfArcCuts = 1 / Math.pow(2, 10 - 1) }) {
+//         this._populateCount = populateCount;
+//         // does the cutting and id mapping(one to many)
+//         // cuts have their bbox ready for rbush
+//         this._rbush = new RBush(1000);
+//         this._arcToCutsManager = new ArcToCutsManager({ dotDistanceOfArcCuts, rbush: this._rbush }); // 10km
+//     }
+//     /**
+//      * adds or updates an arc in the rbush and the cuts manager
+//      */
+//     insertArc(arc: Arc) {
+//         this._arcToCutsManager.insertArc(arc);
+//     }
+//     deleteArc(id: Arc['id']) {
+//         this._arcToCutsManager.deleteArc(id);
+//     }
+//     queryBBox(bbox: BBox) {
+//         const arcIDSet = new Set(this._rbush.query(bbox).map(x => x.id)); // sets Of ids of arcs
+//         // arcs U bbox => arcs
+//         // populate points
+//         // return typed array of points belonging to all the arcs of cuts
+//     }
+// }

package/util/surface-line-data/rbush-manager.js

@@ -0,0 +1 @@
+"use strict";

package/util/surface-line-data/types.js

@@ -0,0 +1 @@
+"use strict";

package/util/surface-line-data/web-worker.js

@@ -0,0 +1 @@
+"use strict";

package/util/webglobe/gldefaultstates.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultblendfunction = defaultblendfunction;
+function defaultblendfunction(gl) {
+    gl.blendEquation(gl.FUNC_ADD); // TODO: TESTING THIS
+    gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+}

package/util/webglobe/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./rasteroverlay"), exports);
+__exportStar(require("./gldefaultstates"), exports);

package/util/webglobe/rasteroverlay.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Iceride bir canvas uretir ve degisiklikler bu kanvasta yapilir
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RasterOverlayLoader = void 0;
+// this class loads texture to raster overlay
+class RasterOverlayLoader {
+    constructor(id, globe, { opacity = 1.0, minLon = -180, minLat = -90, maxLon = 180, maxLat = 90, beforeObject = null, canvas = null, callBack = null } = {}) {
+        this.canvas = canvas || document.createElement('canvas');
+        this.gl = this.canvas.getContext('webgl2');
+        this.globe = globe;
+        this.id = id;
+        this._opacity = opacity;
+        this.bbox = { ll: { x: minLon, y: minLat }, ur: { x: maxLon, y: maxLat } };
+        this._beforeObject = beforeObject;
+        this._isProcessing = false;
+        this._callBack = callBack;
+    }
+    getGL() {
+        return this.gl;
+    }
+    getCanvasURL() {
+        return this.canvas.toDataURL();
+    }
+    setBBox(minLon, minLat, maxLon, maxLat) {
+        this.bbox = { ll: { x: minLon, y: minLat }, ur: { x: maxLon, y: maxLat } };
+        this.draw();
+    }
+    setCanvasWidthHeight(width, height) {
+        this.canvas.width = width;
+        this.canvas.height = height;
+        this.gl.viewport(0, 0, width, height);
+    }
+    draw() {
+        if (!this._isProcessing) {
+            requestAnimationFrame(this._draw.bind(this));
+            this._isProcessing = true;
+        }
+    }
+    _draw() {
+        this.globe.api_DeleteImageOverlay(this.id);
+        const id = this.id;
+        const imgUrl = this.getCanvasURL();
+        const bbox = this.bbox;
+        const opacity = this._opacity;
+        const rotDeg = 0;
+        const color = null;
+        const beforeObject = this._beforeObject;
+        const callback = this._callBack || function () { };
+        this.globe.api_AddImageOverlay(id, imgUrl, bbox, color, opacity, rotDeg, beforeObject, callback);
+        this._isProcessing = false;
+    }
+    setBeforeObject(beforeObject) {
+        this._beforeObject = beforeObject;
+        this.draw();
+    }
+    setCallback(callback) {
+        this._callBack = callback;
+    }
+    setOpacity(opacity) {
+        if (opacity < 0 || opacity > 1) {
+            return;
+        }
+        this._opacity = opacity;
+        this.globe.api_SetImageOverlayColor(this.id, null, opacity);
+    }
+    free() {
+        this.globe.api_DeleteImageOverlay(this.id);
+    }
+    on() {
+        this.draw();
+    }
+    off() {
+        this.globe.api_DeleteImageOverlay(this.id);
+    }
+}
+exports.RasterOverlayLoader = RasterOverlayLoader;