@pirireis/webglobeplugins 0.9.11 → 0.9.13

package/util/programs/texturetoglobe.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextureToGlobeProgram = void 0;
-var webglobjectbuilders_1 = require("../webglobjectbuilders");
-var __1 = require("..");
-var __2 = require("..");
+import { createProgram } from "../webglobjectbuilders";
+import { shaderfunctions } from "..";
+import { latLongBboxtoPixelXYBbox } from "..";
 /** TODO:
  * 3d icin calistir
  */
 //TODO: DELETE THIS FILE. 
-var TextureToGlobeProgram = /** @class */ (function () {
-    function TextureToGlobeProgram(gl, globe) {
+class TextureToGlobeProgram {
+    constructor(gl, globe) {
         this.globe = globe;
         this.gl = gl;
         this._is3D = true;
@@ -17,9 +14,9 @@ var TextureToGlobeProgram = /** @class */ (function () {
         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);
+    _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([
@@ -31,14 +28,65 @@ var TextureToGlobeProgram = /** @class */ (function () {
         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();
+    }
+    _createProgramWrapper() {
+        const gl = this.gl;
+        const vertexSource = `#version 300 es
+            precision highp float;
+
+            in vec2 a_position;
+
+            uniform mat3 u_bbox_matrix;
+
+            uniform mat4 u_model_view_matrix;
+            uniform mat4 u_proj_matrix;
+            uniform vec3 u_transpos;
+
+            uniform vec2 u_mapWH;
+            uniform vec2 u_scrWH;
+
+            uniform bool u_is3D;
+            uniform float height; 
+
+            out vec2 v_texcoord;
+
+
+            ` + shaderfunctions.pixelXYToCartesian3DPoint + `
+            ` + shaderfunctions.pixelXYToCartesian2DPoint + `
+
+
+            void main() {
+                vec3 pos = u_bbox_matrix * vec3(a_position, height);
+                if(u_is3D){
+                    pos = pixelXYToCartesian3DPoint(pos);
+                    gl_Position = u_proj_matrix * u_model_view_matrix * vec4(pos - u_transpos, 1.0);
+                } else {
+                    vec2 xy = pixelXYToCartesian2DPoint(pos.xy, u_transpos.xy, u_mapWH, u_scrWH);
+                    gl_Position = u_proj_matrix * vec4(xy.x, xy.y, 0.0, 1.0);
+                }
+                gl_PointSize = 100.0;
+                v_texcoord = a_position * 0.5 + 0.5; // need a check
+            }
+            `;
+        const fragmentSource = `#version 300 es
+            precision highp float;
+
+            in vec2 v_texcoord;
+
+            uniform float u_alpha;
+            uniform sampler2D u_texture;
+
+            out vec4 outColor;
+
+            void main() {
+                // outColor = texture(u_texture, v_texcoord);
+                // 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([
@@ -47,7 +95,7 @@ var TextureToGlobeProgram = /** @class */ (function () {
             1, 1,
             0, 1
         ]), gl.STATIC_DRAW);
-        var a_position = -gl.getAttribLocation(program, 'a_position');
+        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);
@@ -63,10 +111,10 @@ var TextureToGlobeProgram = /** @class */ (function () {
             u_bbox_matrix: gl.getUniformLocation(program, 'u_bbox_matrix'),
             u_is3D: gl.getUniformLocation(program, 'u_is3D'),
         };
-    };
-    TextureToGlobeProgram.prototype.draw = function (modelViewMatrix, projectionMatrix, transPos, texture) {
+    }
+    draw(modelViewMatrix, projectionMatrix, transPos, texture) {
         // console.log('draw')
-        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper, _is3D = _a._is3D;
+        const { gl, _programWrapper, _is3D } = this;
         gl.useProgram(_programWrapper.program);
         gl.bindVertexArray(_programWrapper.vao);
         gl.uniformMatrix4fv(_programWrapper.u_model_view_matrix, false, modelViewMatrix);
@@ -76,15 +124,15 @@ var TextureToGlobeProgram = /** @class */ (function () {
         gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.uniform1i(_programWrapper.u_texture, 0);
         if (!_is3D) {
-            var mapWH = this.globe.api_GetCurrentWorldWH();
+            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);
-    };
-    TextureToGlobeProgram.prototype.setBBox = function (minx, maxx, miny, maxy) {
-        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper;
-        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+    }
+    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,
@@ -92,41 +140,40 @@ var TextureToGlobeProgram = /** @class */ (function () {
             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);
+    }
+    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);
-    };
-    TextureToGlobeProgram.prototype.setScreenWH = function () {
-        var _a = this, gl = _a.gl, _programWrapper = _a._programWrapper, globe = _a.globe;
-        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+    }
+    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);
-    };
-    TextureToGlobeProgram.prototype.resize = function () {
-        var globe = this.globe;
+    }
+    resize() {
+        const { globe } = this;
         this.setScreenWH();
-    };
-    TextureToGlobeProgram.prototype.setGeometry = function () {
-        var _a = this, gl = _a.gl, globe = _a.globe, _programWrapper = _a._programWrapper;
+    }
+    setGeometry() {
+        const { gl, globe, _programWrapper } = this;
         this._is3D = globe.api_GetCurrentGeometry() === 0;
-        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        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();
-    };
-    TextureToGlobeProgram.prototype.free = function () {
+    }
+    free() {
         window.removeEventListener('resize', this._resizeHandler, true);
-    };
-    TextureToGlobeProgram.prototype._resizeEventHandler = function () {
+    }
+    _resizeEventHandler() {
         this.resize();
-    };
-    return TextureToGlobeProgram;
-}());
-exports.TextureToGlobeProgram = TextureToGlobeProgram;
+    }
+}
+export { TextureToGlobeProgram };

package/util/shaderfunctions/geometrytransformations.js

@@ -1,45 +1,333 @@
-"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";
+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
-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";
+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
-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";
+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. 
-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";
+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.
-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";
+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
-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} ";
+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)
-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} ";
+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
-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;
+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...
-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;
+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/shaderfunctions/index.js

@@ -1,18 +1,2 @@
-"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);
+export * from './geometrytransformations';
+export * from './nodata';

package/util/shaderfunctions/nodata.js

@@ -1,5 +1,8 @@
-"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;
+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);
+}
+`;
+export { vertexIDtoTextureCoordinate };