@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/util/programs/texturetoglobe.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextureToGlobeProgram = void 0;
+var webglobjectbuilders_1 = require("../webglobjectbuilders");
+var __1 = require("..");
+var __2 = require("..");
+/** TODO:
+ * 3d icin calistir
+ */
+//TODO: DELETE THIS FILE. 
+var TextureToGlobeProgram = /** @class */ (function () {
+    function TextureToGlobeProgram(gl, globe) {
+        this.globe = globe;
+        this.gl = gl;
+        this._is3D = true;
+        this._programWrapper = this._createProgramWrapper();
+        this._resizeHandler = this._resizeEventHandler.bind(this);
+        window.addEventListener('resize', this._resizeHandler, true);
+    }
+    TextureToGlobeProgram.prototype._initUniforms = function () {
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        // set u_alpha
+        gl.uniformMatrix3fv(_programWrapper.u_bbox_matrix, false, new Float32Array([
+            1, 0, 0,
+            0, 1, 0,
+            0, 0, 1
+        ]));
+        gl.uniform1f(_programWrapper.u_alpha, 1.0);
+        gl.uniform1f(_programWrapper.u_is3D, 1.0);
+        gl.uniform1f(_programWrapper.height, 0.0);
+        gl.useProgram(currentProgram);
+    };
+    TextureToGlobeProgram.prototype._createProgramWrapper = function () {
+        var gl = this.gl;
+        var vertexSource = "#version 300 es\n            precision highp float;\n\n            in vec2 a_position;\n\n            uniform mat3 u_bbox_matrix;\n\n            uniform mat4 u_model_view_matrix;\n            uniform mat4 u_proj_matrix;\n            uniform vec3 u_transpos;\n\n            uniform vec2 u_mapWH;\n            uniform vec2 u_scrWH;\n\n            uniform bool u_is3D;\n            uniform float height; \n\n            out vec2 v_texcoord;\n\n\n            " + __1.shaderfunctions.pixelXYToCartesian3DPoint + "\n            " + __1.shaderfunctions.pixelXYToCartesian2DPoint + "\n\n\n            void main() {\n                vec3 pos = u_bbox_matrix * vec3(a_position, height);\n                if(u_is3D){\n                    pos = pixelXYToCartesian3DPoint(pos);\n                    gl_Position = u_proj_matrix * u_model_view_matrix * vec4(pos - u_transpos, 1.0);\n                } else {\n                    vec2 xy = pixelXYToCartesian2DPoint(pos.xy, u_transpos.xy, u_mapWH, u_scrWH);\n                    gl_Position = u_proj_matrix * vec4(xy.x, xy.y, 0.0, 1.0);\n                }\n                gl_PointSize = 100.0;\n                v_texcoord = a_position * 0.5 + 0.5; // need a check\n            }\n            ";
+        var fragmentSource = "#version 300 es\n            precision highp float;\n\n            in vec2 v_texcoord;\n\n            uniform float u_alpha;\n            uniform sampler2D u_texture;\n\n            out vec4 outColor;\n\n            void main() {\n                // outColor = texture(u_texture, v_texcoord);\n                // outColor.a *= u_alpha;\n                outColor = vec4(1.0, 0.0, 0.0, 0.5);\n            }   \n            ";
+        var program = (0, webglobjectbuilders_1.createProgram)(gl, vertexSource, fragmentSource);
+        var vao = gl.createVertexArray();
+        var buffer = gl.createBuffer();
+        gl.bindVertexArray(vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+            0, 0,
+            1, 0,
+            1, 1,
+            0, 1
+        ]), gl.STATIC_DRAW);
+        var a_position = -gl.getAttribLocation(program, 'a_position');
+        gl.enableVertexAttribArray(a_position);
+        gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 0, 0);
+        gl.bindVertexArray(null);
+        return {
+            program: program,
+            vao: vao,
+            u_model_view_matrix: gl.getUniformLocation(program, 'u_model_view_matrix'),
+            u_proj_matrix: gl.getUniformLocation(program, 'u_proj_matrix'),
+            u_transpos: gl.getUniformLocation(program, 'u_transpos'),
+            u_mapWH: gl.getUniformLocation(program, 'u_mapWH'),
+            u_scrWH: gl.getUniformLocation(program, 'u_scrWH'),
+            u_texture: gl.getUniformLocation(program, 'u_texture'),
+            u_bbox_matrix: gl.getUniformLocation(program, 'u_bbox_matrix'),
+            u_is3D: gl.getUniformLocation(program, 'u_is3D'),
+        };
+    };
+    TextureToGlobeProgram.prototype.draw = function (modelViewMatrix, projectionMatrix, transPos, texture) {
+        // console.log('draw')
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper, _is3D = _a._is3D;
+        gl.useProgram(_programWrapper.program);
+        gl.bindVertexArray(_programWrapper.vao);
+        gl.uniformMatrix4fv(_programWrapper.u_model_view_matrix, false, modelViewMatrix);
+        gl.uniformMatrix4fv(_programWrapper.u_proj_matrix, false, projectionMatrix);
+        gl.uniform3f(_programWrapper.u_transpos, transPos.x, transPos.y, transPos.z);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.uniform1i(_programWrapper.u_texture, 0);
+        if (!_is3D) {
+            var mapWH = this.globe.api_GetCurrentWorldWH();
+            gl.uniform2f(_programWrapper.u_mapWH, mapWH.width, mapWH.height);
+        }
+        gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
+        gl.drawArrays(gl.POINTS, 0, 4);
+    };
+    TextureToGlobeProgram.prototype.setBBox = function (minx, maxx, miny, maxy) {
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniformMatrix3fv(_programWrapper.u_bbox_matrix, false, new Float32Array([
+            maxx - minx, 0, minx,
+            0, maxy - miny, miny,
+            0, 0, 1
+        ]));
+        gl.useProgram(currentProgram);
+    };
+    TextureToGlobeProgram.prototype.setLatLongBBox = function (minx, maxx, miny, maxy) {
+        var bboxMatrix = (0, __2.latLongBboxtoPixelXYBbox)(minx, miny, maxx, maxy);
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniformMatrix3fv(_programWrapper.u_bbox_matrix, false, bboxMatrix);
+        gl.useProgram(currentProgram);
+    };
+    TextureToGlobeProgram.prototype.setScreenWH = function () {
+        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper, globe = _a.globe;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniform2f(_programWrapper.u_scrWH, globe.api_ScrW(), globe.api_ScrH());
+        gl.useProgram(currentProgram);
+    };
+    TextureToGlobeProgram.prototype.resize = function () {
+        var globe = this.globe;
+        this.setScreenWH();
+    };
+    TextureToGlobeProgram.prototype.setGeometry = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe, _programWrapper = _a._programWrapper;
+        this._is3D = globe.api_GetCurrentGeometry() === 0;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniform1f(_programWrapper.u_is3D, this._is3D ? 1.0 : 0.0);
+        gl.useProgram(currentProgram);
+        this.resize();
+    };
+    TextureToGlobeProgram.prototype.free = function () {
+        window.removeEventListener('resize', this._resizeHandler, true);
+    };
+    TextureToGlobeProgram.prototype._resizeEventHandler = function () {
+        this.resize();
+    };
+    return TextureToGlobeProgram;
+}());
+exports.TextureToGlobeProgram = TextureToGlobeProgram;

package/util/shaderfunctions/geometrytransformations.js

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

package/util/shaderfunctions/noisefunctions.js

@@ -0,0 +1,13 @@
+"use strict";
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var permute34 = ""(templateObject_1 || (templateObject_1 = __makeTemplateObject(["vec3 permute34(vec3 x) {\n    x = ((x * 34.0) + 1.0) * x;\n    return x - floor(x * (1.0 / 289.0)) * 289.0;\n}"], ["vec3 permute34(vec3 x) {\n    x = ((x * 34.0) + 1.0) * x;\n    return x - floor(x * (1.0 / 289.0)) * 289.0;\n}"])))(templateObject_2 || (templateObject_2 = __makeTemplateObject([""], [""])));
+var waveNoice = ""(templateObject_3 || (templateObject_3 = __makeTemplateObject(["float waveNoice(vec2 v)\n{\n    const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439); \n\n\t  vec2 i = floor(v + dot(v, C.yy));\n\t  vec2 x0 = v - i + dot(i, C.xx);\n\n\t  vec2 i1;\n    i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n\n\t  vec4 x12 = x0.xyxy + C.xxzz;\n    x12.xy -= i1;\n\n    i = i - floor(i * (1.0 / 289.0)) * 289.0;\n\n\t  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))\n        + i.x + vec3(0.0, i1.x, 1.0));\n\n\t  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);\n    m = m * m;\n    m = m * m;\n\n\t  vec3 x = 2.0 * fract(p * C.www) - 1.0;\n\t  vec3 h = abs(x) - 0.5;\n\t  vec3 ox = floor(x + 0.5);\n\t  vec3 a0 = x - ox;\n\n    m *= inversesqrt(a0 * a0 + h * h);\n\n\t  vec3 g;\n    g.x = a0.x * x0.x + h.x * x0.y;\n    g.yz = a0.yz * x12.xz + h.yz * x12.yw;\n    return 130.0 * dot(m, g);\n}"], ["float waveNoice(vec2 v)\n{\n    const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439); \n\n\t  vec2 i = floor(v + dot(v, C.yy));\n\t  vec2 x0 = v - i + dot(i, C.xx);\n\n\t  vec2 i1;\n    i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n\n\t  vec4 x12 = x0.xyxy + C.xxzz;\n    x12.xy -= i1;\n\n    i = i - floor(i * (1.0 / 289.0)) * 289.0;\n\n\t  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))\n        + i.x + vec3(0.0, i1.x, 1.0));\n\n\t  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);\n    m = m * m;\n    m = m * m;\n\n\t  vec3 x = 2.0 * fract(p * C.www) - 1.0;\n\t  vec3 h = abs(x) - 0.5;\n\t  vec3 ox = floor(x + 0.5);\n\t  vec3 a0 = x - ox;\n\n    m *= inversesqrt(a0 * a0 + h * h);\n\n\t  vec3 g;\n    g.x = a0.x * x0.x + h.x * x0.y;\n    g.yz = a0.yz * x12.xz + h.yz * x12.yw;\n    return 130.0 * dot(m, g);\n}"])))(templateObject_4 || (templateObject_4 = __makeTemplateObject([""], [""])));
+exports.default = {
+    permute34: permute34,
+    waveNoice: waveNoice
+};
+var templateObject_1, templateObject_2, templateObject_3, templateObject_4;

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,53 @@
+"use strict";
+var ArcsToCutsManager = /** @class */ (function () {
+    function ArcsToCutsManager(rbush, _a) {
+        var _b = _a.dotDistanceOfArcCuts, dotDistanceOfArcCuts = _b === void 0 ? 0.01 : _b;
+        this._map = new Map();
+        this._dotDistanceOfArcCuts = dotDistanceOfArcCuts;
+        this._rbush = rbush;
+    }
+    ArcsToCutsManager.prototype.insertArcs = function (arc) {
+        if (this._map.has(arc.id)) {
+            this._deleteCuts(arc.id);
+        }
+    };
+    ArcsToCutsManager.prototype._deleteCuts = function (id) {
+        var cuts = this._map.get(id);
+        if (cuts) {
+            cuts.forEach(function (cut) { return cut.remove(); });
+        }
+    };
+    ArcsToCutsManager.prototype._cutArcAndAddToRBush = function (arc) {
+        var _this = this;
+        var cuts = this._cutArcToBBoxs(arc);
+        cuts.forEach(function (cut) {
+            _this._rbush.insert(cut);
+        });
+        this._map.set(arc.id, cuts);
+    };
+    ArcsToCutsManager.prototype._cutArcToBBoxs = function (arc) {
+        var cuts = [];
+        // Calculate the bounding box of the arc
+        // Create a cut object and add it to the cuts array
+        var cut = {
+            minX: bbox.minX,
+            minY: bbox.minY,
+            maxX: bbox.maxX,
+            maxY: bbox.maxY,
+            arcId: arc.id,
+        };
+        cuts.push(cut);
+        return cuts;
+    };
+    return ArcsToCutsManager;
+}());
+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
+    var phi = phi1 + t * (phi2 - phi1);
+    var 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,80 @@
+"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
+var RasterOverlayLoader = /** @class */ (function () {
+    function RasterOverlayLoader(id, globe, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.opacity, opacity = _c === void 0 ? 1.0 : _c, _d = _b.minLon, minLon = _d === void 0 ? -180 : _d, _e = _b.minLat, minLat = _e === void 0 ? -90 : _e, _f = _b.maxLon, maxLon = _f === void 0 ? 180 : _f, _g = _b.maxLat, maxLat = _g === void 0 ? 90 : _g, _h = _b.beforeObject, beforeObject = _h === void 0 ? null : _h, _j = _b.canvas, canvas = _j === void 0 ? null : _j, _k = _b.callBack, callBack = _k === void 0 ? null : _k;
+        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;
+    }
+    RasterOverlayLoader.prototype.getGL = function () {
+        return this.gl;
+    };
+    RasterOverlayLoader.prototype.getCanvasURL = function () {
+        return this.canvas.toDataURL();
+    };
+    RasterOverlayLoader.prototype.setBBox = function (minLon, minLat, maxLon, maxLat) {
+        this.bbox = { ll: { x: minLon, y: minLat }, ur: { x: maxLon, y: maxLat } };
+        this.draw();
+    };
+    RasterOverlayLoader.prototype.setCanvasWidthHeight = function (width, height) {
+        this.canvas.width = width;
+        this.canvas.height = height;
+        this.gl.viewport(0, 0, width, height);
+    };
+    RasterOverlayLoader.prototype.draw = function () {
+        if (!this._isProcessing) {
+            requestAnimationFrame(this._draw.bind(this));
+            this._isProcessing = true;
+        }
+    };
+    RasterOverlayLoader.prototype._draw = function () {
+        this.globe.api_DeleteImageOverlay(this.id);
+        var id = this.id;
+        var imgUrl = this.getCanvasURL();
+        var bbox = this.bbox;
+        var opacity = this._opacity;
+        var rotDeg = 0;
+        var color = null;
+        var beforeObject = this._beforeObject;
+        var callback = this._callBack || function () { };
+        this.globe.api_AddImageOverlay(id, imgUrl, bbox, color, opacity, rotDeg, beforeObject, callback);
+        this._isProcessing = false;
+    };
+    RasterOverlayLoader.prototype.setBeforeObject = function (beforeObject) {
+        this._beforeObject = beforeObject;
+        this.draw();
+    };
+    RasterOverlayLoader.prototype.setCallback = function (callback) {
+        this._callBack = callback;
+    };
+    RasterOverlayLoader.prototype.setOpacity = function (opacity) {
+        if (opacity < 0 || opacity > 1) {
+            return;
+        }
+        this._opacity = opacity;
+        this.globe.api_SetImageOverlayColor(this.id, null, opacity);
+    };
+    RasterOverlayLoader.prototype.free = function () {
+        this.globe.api_DeleteImageOverlay(this.id);
+    };
+    RasterOverlayLoader.prototype.on = function () {
+        this.draw();
+    };
+    RasterOverlayLoader.prototype.off = function () {
+        this.globe.api_DeleteImageOverlay(this.id);
+    };
+    return RasterOverlayLoader;
+}());
+exports.RasterOverlayLoader = RasterOverlayLoader;