@pirireis/webglobeplugins 0.8.8 → 0.8.9

package/bearing-line/plugin.js

@@ -442,7 +442,7 @@ export default class BearingLinePlugin {
             ...["centerCoords2dflat", "rgbaMercator", "circleDashAngleMercator", "dashOpacityMercator"
             ].map(key => vaoOBJ(key)));
         this.circle3DVao = this.circle3DProgram.createVAO(
-            ...["centerCoords3d", "bigRadius", "rgba", "circleDashAngle", "dashOpacity", "startAngle3d"
+            ...["centerCoords3d", "targetCoords3d", "rgba", "circleDashAngle", "dashOpacity"
             ].map(key => vaoOBJ(key)));
     }
 

package/circle-line-chain/plugin.js

@@ -292,10 +292,10 @@ export class CircleLineChainPlugin {
                             return new Float32Array(item.chainProperties.rgba);
                         }
                     }],
-                    ["bigRadius", {
-                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.bigRadius])
-                    }],
+                    // ["bigRadius", {
+                    //     'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                    //     'adaptor': (item) => new Float32Array([item.bigRadius])
+                    // }],
                     ["dashRatio", {
                         'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
                         'adaptor': (item) => new Float32Array([item.chainProperties.dashRatio])
@@ -354,7 +354,7 @@ export class CircleLineChainPlugin {
                 ].map(key => obj(key)));
 
             this.circle3DVao = this.circle3DProgram.createVAO(
-                ...["centerCoords3d", "bigRadius", "rgbaCircle", "circleDashAngle", "dashOpacity"
+                ...["centerCoords3d", "targetCoords3d", "rgbaCircle", "circleDashAngle", "dashOpacity"
                 ].map(key => obj(key))
             );
 
@@ -376,7 +376,7 @@ export class CircleLineChainPlugin {
     _reconstructChains(chainKeys) {
         const { globe } = this;
 
-        const radiusM = radiusMethod(globe);
+        // const radiusM = radiusMethod(globe);
         const callback = (v, i, array, chainProperties) => {
             if (i === array.length - 1) return null;
 
@@ -384,7 +384,7 @@ export class CircleLineChainPlugin {
 
             return {
                 chainProperties: chainProperties,
-                bigRadius: radiusM(v, i, array),
+                // bigRadius: radiusM(v, i, array),
                 targetLong: array[i + 1].long,
                 targetLat: array[i + 1].lat,
                 long: v.long,
@@ -458,7 +458,7 @@ export class CircleLineChainPlugin {
 
 
 
-const radiusMethod = (globe) => (v, i, array) => {
-    return globe.Math.GetDist3D(v.long, v.lat, array[i + 1].long, array[i + 1].lat)
-}
+// const radiusMethod = (globe) => (v, i, array) => {
+//     return globe.Math.GetDist3D(v.long, v.lat, array[i + 1].long, array[i + 1].lat)
+// }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.8.8",
+    "version": "0.8.9",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT"

package/programs/line-on-globe/circle-accurate-3d.js

@@ -4,11 +4,11 @@ import { noRegisterGlobeProgramCache } from "../programcache";
 // import { vaoAttributeLoader } from "../../util/account/util";
 import { attributeLoader } from "../../util/gl-util/buffer/integrate-buffer";
 import {
-    longLatRadToMercator, longLatRadToCartesian3D, cartesian3DToGLPosition, mercatorXYToGLPosition, realDistanceOnSphereR1,
+    cartesian3DToGLPosition,
     circleLimpFromLongLatRadCenterCartesian3D_accurate,
-    circleLimpFromLongLatRadCenterMercatorCompass_accurate,
-    circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
-    POLE
+    circleOnSphere,
+    POLE,
+    PI
 } from "../../util/shaderfunctions/geometrytransformations";
 
 
@@ -21,27 +21,22 @@ import {
  * center_position is too small or doenst loaded as expected.
  */
 const EDGE_COUNT_ON_SPHERE = 360;
-
+//${circleLimpFromLongLatRadCenterCartesian3D_accurate}
 const vertexShaderSource = `#version 300 es
 precision highp float;
+${PI}
 ${CameraUniformBlockString}
-${longLatRadToMercator}
-${longLatRadToCartesian3D}
 ${cartesian3DToGLPosition}
-${mercatorXYToGLPosition}
-${realDistanceOnSphereR1}
-${circleLimpFromLongLatRadCenterCartesian3D_accurate}
-${circleLimpFromLongLatRadCenterMercatorCompass_accurate}
-${circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate}
+${circleOnSphere}
 
 uniform float edge_count;
 
 in vec3 center_position3d;
-in float radius;
+in vec3 target_position3d;
+// in float radius;
 in vec4 color;
 in float dash_ratio;
 in float dash_opacity;
-in float initial_angle;
 
 out float interpolation;
 out vec4 v_color;
@@ -51,7 +46,7 @@ void main() {
     interpolation = float( gl_VertexID ) / ${EDGE_COUNT_ON_SPHERE}.0;
     if ( is3D ) {
         float angle = PI * 2.0 * interpolation;
-        vec3 position = circleLimpFromLongLatRadCenterCartesian3D_accurate(center_position3d, radius, angle + initial_angle);
+        vec3 position = circleOnSphere(center_position3d, target_position3d, angle);
         gl_Position = cartesian3DToGLPosition(position);
     } else {
         return;
@@ -107,11 +102,10 @@ class Logic {
 
         {   // assign attribute locations
             gl.bindAttribLocation(program, 0, "center_position3d");
-            gl.bindAttribLocation(program, 1, "radius");
+            gl.bindAttribLocation(program, 1, "target_position3d");
             gl.bindAttribLocation(program, 2, "color");
             gl.bindAttribLocation(program, 3, "dash_ratio");
             gl.bindAttribLocation(program, 4, "dash_opacity");
-            gl.bindAttribLocation(program, 5, "initial_angle");
         }
 
         this.cameraBindingPoint = 0;
@@ -120,7 +114,7 @@ class Logic {
         gl.uniformBlockBinding(program, cameraBlockLocation, this.cameraBindingPoint);
     }
 
-    createVAO(center3dObj, radiusObj, colorObj, dashRatioObj, dashOpacityObj, initialAngleObj) {
+    createVAO(center3dObj, target3dObj, colorObj, dashRatioObj, dashOpacityObj) {
         const { gl } = this;
         const vao = gl.createVertexArray();
         const divisor = 1;
@@ -128,11 +122,11 @@ class Logic {
         gl.bindVertexArray(vao);
 
         attributeLoader(gl, center3dObj, 0, 3, { divisor });
-        attributeLoader(gl, radiusObj, 1, 1, { divisor });
+        attributeLoader(gl, target3dObj, 1, 3, { divisor });
+        // attributeLoader(gl, radiusObj, 1, 1, { divisor });
         attributeLoader(gl, colorObj, 2, 4, { divisor });
         attributeLoader(gl, dashRatioObj, 3, 1, { divisor });
         attributeLoader(gl, dashOpacityObj, 4, 1, { divisor });
-        attributeLoader(gl, initialAngleObj, 5, 1, { divisor, escapeValues: [0] });
 
 
         gl.bindVertexArray(null);

package/rangerings/plugin.js

@@ -106,7 +106,7 @@ class RangeRings {
         } = this;
         for (const { centerID } of items) {
             const datas = this.__reconstructCentralRings(centerID);
-            bufferOrchestrator.updateBulk(datas, bufferManagersCompMap, ["centerCoords3d", "centerCoords2dflat", "centerCoords2dflatForPadding"]);
+            bufferOrchestrator.updateBulk(datas, bufferManagersCompMap, ["centerCoords3d", "centerCoords2dflat", "targetCoords3d", "centerCoords2dflatForPadding"]);
             const paddingDatas = this.__reconstructCentralRingsBigPaddings(centerID);
             paddingBufferOrchestrator.updateBulk(paddingDatas, bufferManagersCompMapPadding, ["circlePoint", "paddingPoint", "circlePoint3d", "paddingPoint3d"]);
         }
@@ -329,6 +329,11 @@ class RangeRings {
                     'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
                     'adaptor': (item) => new Float32Array(item.centerCoords3d),
                 }],
+                ["targetCoords3d", {
+                    'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
+                    'adaptor': (item) => new Float32Array(item.targetCoords3d),
+                }],
+
                 ["rgba", {
                     'bufferManager': new BufferManager(gl, 4, { bufferType, initialCapacity }),
                     'adaptor': (item) => new Float32Array(item.hide === ENUM_HIDE.HIDE ? [0, 0, 0, 0] : item.rgba)
@@ -385,8 +390,9 @@ class RangeRings {
         this._circle2DVao = this._circleProgram2D.createVAO(
             ...["centerCoords2dflat", "rgbaMercator", "circleDashAngleMercator", "dashOpacityMercator"].map(key => obj(this.bufferManagersCompMap.get(key)))
         );
+
         this._circle3DVao = this._circleProgram3D.createVAO(
-            ...["centerCoords3d", "radius3d", "rgba", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key)))
+            ...["centerCoords3d", "targetCoords3d", "rgba", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key)))
         );
 
         this._oneDegree2DPaddingVao = this._padding2dProgram.createVAO(
@@ -441,6 +447,8 @@ class RangeRings {
             ...["centerCoords3d", "radius3d", "radius3dsmall", "rgba"].map(key => obj(this.bufferManagersCompMap.get(key)))
         );
 
+
+
     }
 
 
@@ -489,10 +497,13 @@ class RangeRings {
             const key = __identity__;
             const centerCoords2dflat = centerCoords2dflatDataCreatorWithRadius(globe, long, lat, radius, { edgeCount: CIRCLE_FLAT_EDGE_COUNT });
             const radiusPadding = hide === ENUM_HIDE.HIDE_1_DEGREE_PADDINGS ? radius : radius - padding / 3;
+            const targetPoint = globe.Math.FindPointByPolar(long, lat, radius, 0); // long lat
+            const targetCoords3d = new Float32Array(globe.api_GetCartesian3DPoint(targetPoint.long, targetPoint.lat, 0, 0));
             const centerCoords2dflatForPadding = centerCoords2dflatDataCreatorWithRadius(globe, long, lat, radiusPadding, { edgeCount: CIRCLE_FLAT_EDGE_COUNT });
             result.push({
                 key,
                 centerCoords3d,
+                targetCoords3d,
                 centerCoords2dflat,
                 radius,
                 padding,

package/util/shaderfunctions/geometrytransformations.js

@@ -245,10 +245,10 @@ vec3 pointsOnSphereBetween(vec3 a, vec3 b, float ratio) {
     b = normalize(b);
 
     // Compute the dot product and clamp it to avoid numerical issues
-    float dotProduct = clamp(dot(a, b), -1.0, 1.0);
+    // float dotProduct = clamp(dot(a, b), -1.0, 1.0);
 
     // Compute the angle between the points
-    float theta = acos(dotProduct);
+    float theta = acos(dot(a, b));
 
     // Handle the edge case where the points are nearly identical
     if (theta < 0.0001) {
@@ -284,7 +284,66 @@ vec3 circleLimpFromLongLatRadCenterCartesian3D_accurate( vec3 geoW, float radius
     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;
+    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 = `
@@ -324,6 +383,6 @@ export {
     slerp,
     circleLimpFromLongLatRadCenterCartesian3D_accurate,
     circleLimpFromLongLatRadCenterMercatorCompass_accurate,
-    circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate
-
+    circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
+    circleOnSphere,
 }