@pirireis/webglobeplugins 0.15.34 → 0.16.0

package/util/programs/texturetoglobe.js

@@ -1,36 +1,42 @@
-import { createProgram } from "../webglobjectbuilders";
-import { shaderfunctions } from "..";
-import { latLongBboxtoPixelXYBbox } from "..";
-/** TODO:
- * 3d icin calistir
- */
-//TODO: DELETE THIS FILE. 
-class TextureToGlobeProgram {
-    constructor(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);
-    }
-    _initUniforms() {
-        const { gl, _programWrapper } = this;
-        const 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);
-    }
-    _createProgramWrapper() {
-        const gl = this.gl;
+import { createProgram } from "../webglobjectbuilders";
+import { shaderfunctions } from "..";
+import { latLongBboxtoPixelXYBbox } from "..";
+/** TODO:
+ * 3d icin calistir
+ */
+//TODO: DELETE THIS FILE. 
+
+class TextureToGlobeProgram {
+    constructor(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);
+    }
+
+    _initUniforms() {
+
+        const { gl, _programWrapper } = this;
+        const 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);
+
+    }
+
+    _createProgramWrapper() {
+        const gl = this.gl;
         const vertexSource = `#version 300 es
             precision highp float;
 
@@ -67,7 +73,8 @@ class TextureToGlobeProgram {
                 gl_PointSize = 100.0;
                 v_texcoord = a_position * 0.5 + 0.5; // need a check
             }
-            `;
+            `;
+
         const fragmentSource = `#version 300 es
             precision highp float;
 
@@ -83,97 +90,114 @@ class TextureToGlobeProgram {
                 // outColor.a *= u_alpha;
                 outColor = vec4(1.0, 0.0, 0.0, 0.5);
             }   
-            `;
-        const program = createProgram(gl, vertexSource, fragmentSource);
-        const vao = gl.createVertexArray();
-        const 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);
-        const 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'),
-        };
-    }
-    draw(modelViewMatrix, projectionMatrix, transPos, texture) {
-        // console.log('draw')
-        const { gl, _programWrapper, _is3D } = this;
-        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) {
-            const 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);
-    }
-    setBBox(minx, maxx, miny, maxy) {
-        const { gl, _programWrapper } = this;
-        const 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);
-    }
-    setLatLongBBox(minx, maxx, miny, maxy) {
-        const bboxMatrix = latLongBboxtoPixelXYBbox(minx, miny, maxx, maxy);
-        const { gl, _programWrapper } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        gl.useProgram(_programWrapper.program);
-        gl.uniformMatrix3fv(_programWrapper.u_bbox_matrix, false, bboxMatrix);
-        gl.useProgram(currentProgram);
-    }
-    setScreenWH() {
-        const { gl, _programWrapper, globe } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        gl.useProgram(_programWrapper.program);
-        gl.uniform2f(_programWrapper.u_scrWH, globe.api_ScrW(), globe.api_ScrH());
-        gl.useProgram(currentProgram);
-    }
-    resize() {
-        const { globe } = this;
-        this.setScreenWH();
-    }
-    setGeometry() {
-        const { gl, globe, _programWrapper } = this;
-        this._is3D = globe.api_GetCurrentGeometry() === 0;
-        const 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();
-    }
-    free() {
-        window.removeEventListener('resize', this._resizeHandler, true);
-    }
-    _resizeEventHandler() {
-        this.resize();
-    }
-}
-export { TextureToGlobeProgram };
+            `;
+
+        const program = createProgram(gl, vertexSource, fragmentSource);
+        const vao = gl.createVertexArray();
+
+        const 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);
+        const 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'),
+        };
+    }
+
+    draw(modelViewMatrix, projectionMatrix, transPos, texture) {
+        // console.log('draw')
+        const { gl, _programWrapper, _is3D } = this;
+        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) {
+            const 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);
+    }
+
+    setBBox(minx, maxx, miny, maxy) {
+        const { gl, _programWrapper } = this;
+        const 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);
+    }
+
+    setLatLongBBox(minx, maxx, miny, maxy) {
+        const bboxMatrix = latLongBboxtoPixelXYBbox(minx, miny, maxx, maxy);
+        const { gl, _programWrapper } = this;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniformMatrix3fv(_programWrapper.u_bbox_matrix, false, bboxMatrix);
+        gl.useProgram(currentProgram);
+    }
+
+
+    setScreenWH() {
+        const { gl, _programWrapper, globe } = this;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniform2f(_programWrapper.u_scrWH, globe.api_ScrW(), globe.api_ScrH());
+        gl.useProgram(currentProgram);
+    }
+
+
+    resize() {
+        const { globe } = this;
+        this.setScreenWH();
+    }
+
+    setGeometry() {
+        const { gl, globe, _programWrapper } = this;
+        this._is3D = globe.api_GetCurrentGeometry() === 0;
+        const 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();
+    }
+
+    free() {
+        window.removeEventListener('resize',
+            this._resizeHandler, true);
+    }
+
+    _resizeEventHandler() {
+        this.resize();
+    }
+
+}
+
+export { TextureToGlobeProgram };

package/util/shaderfunctions/geometrytransformations.ts

@@ -0,0 +1,388 @@
+// 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,
+}