@pirireis/webglobeplugins 0.16.0 → 0.16.2

package/util/shaderfunctions/geometrytransformations.ts

@@ -1,388 +0,0 @@
-// Z in kolometers
-// 
-
-
-
-export const POLE = `
-#ifndef POLE
-#define POLE 20037508.34
-#endif
-`;
-
-export const R = `
-#ifndef R
-#define R 6378137.0
-#endif
-`;
-
-export const PI = `
-#ifndef PI
-#define PI 3.141592653589793
-
-#endif
-`;
-
-export const POLE_BY_PI = ` 
-#ifndef POLE_BY_PI
-#define POLE_BY_PI 6378137.0
-#endif
-`;
-
-export const R_3D = `
-#ifndef R_3D
-#define R_3D 6378.137
-#endif
-`;
-
-export const pixelXYToCartesian3DPoint = R_3D + 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);
-}
-`;
-
-export const pixelXYToCartesian2DPoint = PI + POLE + 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
-export const 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);
-} 
-`;
-
-export const cartesian3DToGLPosition = `
-vec4 cartesian3DToGLPosition( vec3 position) {
-    return projection * view * vec4(position - translate, 1.0);
-}
-`
-
-
-// pi / pole = 2 / R
-
-export const longLatRadToMercator = R + 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);
-}
-`;
-
-
-export const longLatRadToCartesian3D = 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);
-}
-`;
-
-export const 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. 
-export const circleLimpFromLongLatRadCenterCartesian3D = 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.
-
-export const circleLimpFromLongLatRadCenterMercatorRealDistanceNew = 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)) 
-    );
-}`;
-
-
-export const circleLimpFromLongLatRadCenterMercatorRealDistance = 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
-export const 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);
-}
-`
-
-
-export const 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)
-export const 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
-
-
-
-export const 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;
-}
-`
-
-export const 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;
-}
-`
-
-
-
-
-export const 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);
-}
-`
-
-const circleLimpFromLongLatRadCenterCartesian3D_accurate = 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;
-}`;
-
-
-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;
-}`;
-
-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);
-} `;
-
-//TODO make it work...
-const circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate = 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;
-}`;
-
-export {
-    slerp,
-    circleLimpFromLongLatRadCenterCartesian3D_accurate,
-    circleLimpFromLongLatRadCenterMercatorCompass_accurate,
-    circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
-    circleOnSphere,
-}

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

@@ -1,42 +0,0 @@
-
-
-// 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/flow.ts

@@ -1,52 +0,0 @@
-
-
-
-
-// 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/types.ts

@@ -1,27 +0,0 @@
-type BBox = {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-    id?: string;
-}
-
-type Point = { lon: number, lat: number };
-type Vector = [number, number, number];  // x y z 
-
-
-type Arc = {
-    id: string;
-    start: number[];
-    end: number[];
-};
-
-
-interface RBUSH {
-    insert: (item: BBox) => void;
-    remove: (item: BBox) => void;
-    search: (bbox: BBox) => BBox[];
-    clear: () => void;
-    all: () => BBox[];
-
-}