@pirireis/webglobeplugins 0.17.0 → 1.0.2

package/util/shaderfunctions/{geometrytransformations.js → geometrytransformations.ts}

@@ -1,32 +1,39 @@
-// Z in kolometers
-// 
-const EPSILON = 0.00001;
+// Z in kolometers
+// 
+
+const EPSILON = 0.00001;
+
 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);
@@ -37,7 +44,8 @@ vec3 pixelXYToCartesian3DPoint( vec3 position) {
     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;
@@ -46,21 +54,26 @@ vec2 pixelXYToCartesian2DPoint( vec2 position, vec2 translate, vec2 mapWH, vec2
     y = (1.0 - (y - translate.y) / mapWH.y) * screenWH.y;
     return  vec2(x, y);
 }
-`;
-// TODO: rename it to mercatorXYToGLPosition
+`;
+
+// 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
+`
+
+
+// pi / pole = 2 / R
+
 export const longLatRadToMercator = R + PI + `
 vec2 longLatRadToMercator( vec2 longLatRad) {
     float x = R * longLatRad.x;
@@ -68,7 +81,9 @@ vec2 longLatRadToMercator( vec2 longLatRad) {
     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);
@@ -76,7 +91,8 @@ vec3 longLatRadToCartesian3D( vec2 longLat) {
     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);
@@ -84,8 +100,9 @@ vec3 longLatRadToCartesian3DWithR( vec2 longLat, float radius) {
     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. 
+`;
+
+// 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);
@@ -99,8 +116,12 @@ vec3 circleLimpFromLongLatRadCenterCartesian3D( vec2 center, float radius, float
     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.
+`;
+
+
+
+// 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
@@ -119,7 +140,9 @@ vec2 circleLimpFromLongLatRadCenterMercatorRealDistance(vec2 center, float radiu
         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
@@ -129,8 +152,9 @@ vec2 circleLimpFromLongLatRadCenterMercatorRealDistance(vec2 center, float radiu
     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
+`;
+
+// TODO: reconstruct this function
 export const circleLimpFromLongLatRadCenterMercatorRealDistancePadding = `
 vec2 circleLimpFromLongLatRadCenterMercatorRealDistancePadding(vec2 center, float radius, float angle){
     float radius_radian = radius / R;
@@ -156,23 +180,31 @@ vec2 circleLimpFromLongLatRadCenterMercatorRealDistancePadding(vec2 center, floa
     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)
+} `;
+
+
+// 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
+} `;
+
+// 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));
@@ -180,7 +212,8 @@ float angleBetweenTwoPointsRadian(vec2 start_, vec2 end_) {
     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;
@@ -188,7 +221,39 @@ float circleCircumferenceInterPolationOf2PointsRadian(vec2 center, vec2 target,
     float angle = mainAngle -  * ratio;
     return angle;
 }
-`;
+`
+
+
+export const slopeFromTexture = R + PI + `
+float slopeFromTexture(highp sampler2DArray heightMap, vec3 uv, vec2 texelSize) {
+    float hL = texture(heightMap, uv - vec3(texelSize.x, 0.0, 0.0)).r;
+    float hR = texture(heightMap, uv + vec3(texelSize.x, 0.0, 0.0)).r;
+    float hD = texture(heightMap, uv - vec3(0.0, texelSize.y, 0.0)).r;
+    float hU = texture(heightMap, uv + vec3(0.0, texelSize.y, 0.0)).r;
+    float dX = (hR - hL) / (2.0 * texelSize.x);
+    float dY = (hU - hD) / (2.0 * texelSize.y);
+    float slope = sqrt(dX * dX + dY * dY);
+    return slope;
+}
+`;
+
+export const normalFromTexture = `
+vec3 normalFromTexture(highp sampler2DArray heightMap, vec3 uv, vec2 texelSize, float strength) {
+    float hL = texture(heightMap, uv - vec3(texelSize.x, 0.0, 0.0)).r;
+    float hR = texture(heightMap, uv + vec3(texelSize.x, 0.0, 0.0)).r;
+    float hD = texture(heightMap, uv - vec3(0.0, texelSize.y, 0.0)).r;
+    float hU = texture(heightMap, uv + vec3(0.0, texelSize.y, 0.0)).r;
+    
+    // Calculate gradient
+    // Strength factor controls how "bumpy" the terrain looks
+    float dX = (hR - hL) * strength;
+    float dY = (hU - hD) * strength;
+    
+    // Return normalized surface normal (-dX, -dY, 1.0)
+    return normalize(vec3(-dX, -dY, 1.0));
+}
+`;
+
 export const realDistanceOnSphereR1 = `
 float realDistanceOnSphereR1(vec2 longLat1, vec2 longLat2) {
     float dLat = longLat2.y - longLat1.y;
@@ -197,12 +262,59 @@ float realDistanceOnSphereR1(vec2 longLat1, vec2 longLat2) {
     float c = 2.0 * atan(sqrt(a), sqrt(1.0 - a));
     return c;
 }
-`;
+`;
+
+
 export const isPointInBBox = `
 bool isPointInBBox(vec2 point, vec4 bbox) {
-    return point.x + ${EPSILON} >= bbox.x && point.x <= bbox.z + ${EPSILON} && point.y + ${EPSILON} >= bbox.y && point.y <= bbox.w + ${EPSILON};
+    return point.x + ${EPSILON} >= bbox.x && point.x <= bbox.z + ${EPSILON}&& point.y + ${EPSILON} >= bbox.y && point.y <= bbox.w + ${EPSILON};
+}
+`;
+
+
+export const relativeBBoxPositionRadian = `
+${PI}
+${isPointInBBox}
+vec2 relativeBBoxPositionRadian(vec2 point, vec4 bbox) {
+    if ( bbox.z > bbox.x) {
+        if ( isPointInBBox(point, bbox) ) {
+            float x_ratio = (point.x - bbox.x) / (bbox.z - bbox.x);
+            float y_ratio = (point.y - bbox.y) / (bbox.w - bbox.y);
+            return vec2(x_ratio, y_ratio);
+        }
+        return vec2(-1.0, -1.0);
+    }
+    else {
+        // BBox crosses the antimeridian
+        if ( isPointInBBox(point, vec4(bbox.x, bbox.y, PI , bbox.w) ) ) {
+            float x_ratio = (point.x - bbox.x) / (PI - bbox.x);
+            float y_ratio = (point.y - bbox.y) / (bbox.w - bbox.y);
+            return vec2(x_ratio, y_ratio);
+        }
+        else if ( isPointInBBox(point, vec4(-PI, bbox.y, bbox.z, bbox.w) ) ) {
+            float x_ratio = (point.x + PI) / (bbox.z + PI);
+            float y_ratio = (point.y - bbox.y) / (bbox.w - bbox.y);
+            return vec2(x_ratio, y_ratio);
+        }
+    }
+    return vec2(-1.0, -1.0);
+}
+`;
+
+
+
+
+export const isPointInBBox2 = `
+bool isPointInBBox(vec2 point, vec4 bbox) {
+    float horizontal_epsilon = (bbox.z - bbox.x) * 0.05;
+    float vertical_epsilon = (bbox.w - bbox.y) * 0.05;
+    return point.x + horizontal_epsilon >= bbox.x &&
+     point.x <= bbox.z + horizontal_epsilon &&
+      point.y + vertical_epsilon >= bbox.y &&
+       point.y <= bbox.w + vertical_epsilon;
 }
-`;
+`;
+
 const pointsOnSphereBetween = `
 vec3 pointsOnSphereBetween(vec3 a, vec3 b, float ratio) {
     // Normalize the input points to ensure they are on the unit sphere
@@ -229,13 +341,16 @@ vec3 pointsOnSphereBetween(vec3 a, vec3 b, float ratio) {
 
     // 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);
@@ -247,7 +362,9 @@ vec3 circleLimpFromLongLatRadCenterCartesian3D_accurate( vec3 geoW, float radius
     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);
@@ -304,14 +421,16 @@ vec3 circleOnSphere(vec3 M, vec3 H, float A) {
 
     // 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...
+} `;
+
+//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 )));
@@ -335,5 +454,14 @@ vec2 circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate(vec2 mercato
         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, };
+}`;
+
+
+
+export {
+    slerp,
+    circleLimpFromLongLatRadCenterCartesian3D_accurate,
+    circleLimpFromLongLatRadCenterMercatorCompass_accurate,
+    circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
+    circleOnSphere,
+}

package/util/shaderfunctions/index.js

@@ -1,2 +1,2 @@
-export * from './geometrytransformations';
-export * from './nodata';
+export * from './geometrytransformations';
+export * from './nodata';

package/util/shaderfunctions/nodata.js

@@ -4,5 +4,7 @@ vec2 vertexIDtoTextureCoordinate(float id, vec2 textureDimentions) {
     float y = floor(id / textureDimentions.x);
     return vec2( x / textureDimentions.x, y / textureDimentions.y);
 }
-`;
-export { vertexIDtoTextureCoordinate };
+`;
+
+
+export {vertexIDtoTextureCoordinate};

package/util/shaderfunctions/noisefunctions.js

@@ -1,8 +1,9 @@
-const permute34 = `` `vec3 permute34(vec3 x) {
+const permute34 = ```vec3 permute34(vec3 x) {
     x = ((x * 34.0) + 1.0) * x;
     return x - floor(x * (1.0 / 289.0)) * 289.0;
-}` ``;
-const waveNoice = `` `float waveNoice(vec2 v)
+}```;
+
+const waveNoice = ```float waveNoice(vec2 v)
 {
     const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439); 
 
@@ -35,7 +36,9 @@ const waveNoice = `` `float waveNoice(vec2 v)
     g.x = a0.x * x0.x + h.x * x0.y;
     g.yz = a0.yz * x12.xz + h.yz * x12.yw;
     return 130.0 * dot(m, g);
-}` ``;
-export default {
-    permute34, waveNoice
-};
+}```;
+
+
+export default {
+    permute34, waveNoice
+}