@pirireis/webglobeplugins 0.15.21-alpha → 0.15.22-alpha

package/Math/arc.js

@@ -143,8 +143,7 @@ function _populatePointsWithClosestPointInsideArc(out, arc, count, closestPoint)
  * @param {Vec3} cameraPosition - The position of the camera.
  * @param {number} quaternionReuseCount - The number of times to apply the same rotation before recalculating. Higher is faster but less accurate.
  */
-function _distanceSampling(out, count, inArc, cameraPosition = vec3create(0, 0, 0), // TODO
-quaternionReuseCount = 1) {
+function _distanceSampling(out, count, inArc, cameraPosition = vec3create(0, 0, 0), quaternionReuseCount = 1) {
     if (count === 0) {
         return;
     }

package/Math/circle-cdf-points.js

@@ -1,168 +1,4 @@
 import { RADIANS } from "./methods";
-function createTemplate(intervalCount, strength = 1.0) {
-    const out = new Array(intervalCount);
-    const TOTAL = 1;
-    let cummulative = 0;
-    if (strength <= 0) {
-        // If strength is 0, distribute evenly.
-        const step = TOTAL / (intervalCount - 1);
-        for (let i = 0; i < intervalCount; i++) {
-            out[i] = cummulative;
-            cummulative += step;
-        }
-        out[intervalCount - 1] = TOTAL; // Ensure the last value is exactly TOTAL
-        return out;
-    }
-    // If strength is greater than 0, bias towards the start.
-    const weights = new Array(intervalCount);
-    let currentStep = 1;
-    let totalWeight = 0;
-    // Calculate weights for each interval, decreasing for later intervals.
-    for (let i = 0; i < intervalCount; i++) {
-        // Using (i + 1) in the denominator gives earlier intervals the highest weight.
-        totalWeight += currentStep;
-        weights[i] = totalWeight;
-        currentStep += strength;
-    }
-    // Distribute the total angle based on the weights.
-    for (let i = 0; i < intervalCount; i++) {
-        // Round to the nearest whole number for this interval.
-        out[i] = (weights[i] / totalWeight) * TOTAL;
-    }
-    if (out[intervalCount - 1] !== TOTAL) {
-        out[intervalCount - 1] = TOTAL;
-    }
-    // console.log("createTemplate", "strength", strength, "intervalCount", intervalCount, "out", out);
-    return out;
-}
-function interpolation(a, b, t) {
-    return a + (b - a) * t;
-}
-/**
- * Populates the `out` array with values from the `template` array,
- * distributing the surplus length as interpolated values between the template samples.
- *
- * @param out The destination array to be filled. Its length must be >= template.length.
- * @param template An ordered array of numbers to be placed in the `out` array.
- * @param strength A parameter controlling the distribution bias of surplus samples.
- * - strength = 0: Surplus samples are distributed evenly.
- * - strength > 0: Surplus samples are biased towards the start of the template.
- * - Higher values create a stronger bias.
- */
-function increasePopulation(// TODO: THERE IS A BUG
-out, template, strength = 1.0) {
-    const sourceLength = template.length;
-    const destinationLength = out.length;
-    const outLengthAtStart = out.length;
-    // --- Handle Edge Cases ---
-    // If the template is empty, there is nothing to interpolate from.
-    if (sourceLength === 0) {
-        return;
-    }
-    // If the template has only one value, fill the output array with that value.
-    if (sourceLength === 1) {
-        out.fill(template[0]);
-        return;
-    }
-    // If the destination is not larger than the source, just copy the template values.
-    if (destinationLength <= sourceLength) {
-        for (let i = 0; i < destinationLength; i++) {
-            out[i] = template[i];
-        }
-        return;
-    }
-    // --- Main Logic ---
-    const surplus = destinationLength - sourceLength;
-    const numGaps = sourceLength - 1;
-    // This array will hold the number of extra samples to add in each gap.
-    const surplusPerGap = new Array(numGaps).fill(0);
-    if (surplus > 0) {
-        // --- Step 1: Determine the distribution of surplus items ---
-        // If strength is 0, distribute surplus items as evenly as possible.
-        if (strength <= 0) {
-            const baseToAdd = Math.floor(surplus / numGaps);
-            const remainder = surplus % numGaps;
-            for (let i = 0; i < numGaps; i++) {
-                // Distribute the remainder one by one to the first gaps.
-                surplusPerGap[i] = baseToAdd + (i < remainder ? 1 : 0);
-            }
-        }
-        else {
-            // Biased Distribution: more items in earlier gaps.
-            const weights = new Array(numGaps);
-            let totalWeight = 0;
-            // A. Calculate a weight for each gap. The weight decreases for later gaps.
-            // The `strength` parameter makes this decay steeper.
-            for (let i = 0; i < numGaps; i++) {
-                // Using (i + 1) in the denominator gives earlier gaps (i=0) the highest weight.
-                const weight = Math.pow(1 / (i + 1), strength);
-                weights[i] = weight;
-                totalWeight += weight;
-            }
-            // B. Distribute the surplus based on the calculated weights.
-            // This method ensures the total distributed count equals the surplus.
-            let distributedCount = 0;
-            for (let i = 0; i < numGaps - 1; i++) {
-                const idealCount = (weights[i] / totalWeight) * surplus;
-                // Round to the nearest whole number for this gap.
-                const countForThisGap = Math.ceil(idealCount);
-                surplusPerGap[i] = countForThisGap;
-                distributedCount += countForThisGap;
-            }
-            // Assign the remainder to the last gap to guarantee the sum is correct.
-            //surplusPerGap[numGaps - 1] = surplus - distributedCount; 
-            // add to first 
-            const leftover = surplus - distributedCount;
-            if (leftover > 0) {
-                surplusPerGap[0] += leftover; // Add any leftover to the first gap.
-            }
-            console.log("leftover", leftover, "distributedCount", distributedCount, "surplus", surplus);
-        }
-    }
-    // --- Step 2: Populate the `out` array ---
-    let outIndex = 0;
-    for (let i = 0; i < surplusPerGap.length; i++) {
-        if (typeof surplusPerGap[i] !== "number" || isNaN(surplusPerGap[i]) || !isFinite(surplusPerGap[i])) {
-            console.warn("increasePopulation: Invalid surplusPerGap value at index", i, ":", surplusPerGap[i]);
-        }
-    }
-    for (let i = 0; i < sourceLength; i++) {
-        // A. Add the original template item.
-        out[outIndex++] = template[i];
-        // B. If this is not the last template item, fill the gap after it.
-        if (i < numGaps) {
-            const numToAdd = surplusPerGap[i];
-            if (numToAdd <= 0)
-                continue;
-            const startVal = template[i];
-            const endVal = template[i + 1];
-            // C. Add the interpolated ("surplus") items for this gap.
-            // The total number of intervals in this gap is numToAdd + 1.
-            const totalIntervals = numToAdd + 1;
-            for (let j = 1; j <= numToAdd; j++) {
-                const t = j / totalIntervals; // The interpolation factor (0 < t < 1)
-                // Linear interpolation: out = start * (1 - t) + end * t
-                const interpolatedValue = startVal * (1 - t) + endVal * t;
-                out[outIndex++] = interpolatedValue;
-                if (outIndex >= out.length) {
-                    console.warn("increasePopulation: Output array overflow. Stopping early.");
-                    console.warn("processeed item ratio:", i, "/", sourceLength);
-                    let count = numToAdd - j;
-                    console.log("count", count);
-                    for (let _i = i; _i < sourceLength; _i++) {
-                        count += surplusPerGap[_i];
-                    }
-                    console.warn("increasePopulation: Not enough space to add", count, "more items.");
-                    return; // Prevent overflow if the output array is not large enough.
-                }
-            }
-        }
-    }
-    // --- Step 3: Ensure the output length is correct ---
-    if (outLengthAtStart !== out.length) {
-        console.warn("increasePopulation: Output length mismatch. Expected", outLengthAtStart, "but got", out.length);
-    }
-}
 function createCummulativeTemplate(numberOfPoints, strength, denseRatio = 0.5 // Ratio of points to be densely packed at the start.
 ) {
     // Handle edge cases for the number of points.
@@ -239,9 +75,4 @@ function globeFindPointByPolarHalfCircle(out, globe, centerLong, centerLat, radi
         offset -= 2;
     }
 }
-export { 
-// createTemplate,
-// increasePopulation,
-// interpolation,
-// createCummulativeTemplate,
-createCummulativeTemplateStash, globeFindPointByPolar, globeFindPointByPolarHalfCircle };
+export { createCummulativeTemplateStash, globeFindPointByPolar, globeFindPointByPolarHalfCircle };

package/Math/circle.js

@@ -29,30 +29,5 @@ function createCircleClosestAzimuthAngleProperties(circle) {
         normal: normal,
         northPointProjectedToOriginPlaneNormalized: N,
     };
-    // const distance = normal[2]; //dot(normal, [0, 0, 1] as Vec3)
-    // const N: Vec3 = [0, 0, 0];
-    // if (Math.abs(distance) < 1e-6) {
-    //     N[0] = -1;
-    //     N[1] = 0;
-    //     N[2] = 0;
-    // } else {
-    //     // TODO: add cases for 8 parts of the sphere
-    //     copy(N, normal);
-    //     multiplyScalar(N, N, distance);
-    //     if (N[2] >= 0) {
-    //         N[0] = -N[0];
-    //         N[1] = -N[1];
-    //         N[2] = 1 - N[2];
-    //     } else {
-    //         N[2] = -N[2];
-    //         N[0] = -N[0];
-    //         N[1] = -N[1];
-    //     }
-    // }
-    // normalize(N, N);
-    // return {
-    //     normal: normal,
-    //     northPointProjectedToOriginPlaneNormalized: N,
-    // }
 }
 export { closestAzimuthAngle, createCircleClosestAzimuthAngleProperties };

package/Math/vec3.js

@@ -85,7 +85,7 @@ function equals(a, b) {
         Math.abs(a[2] - b[2]) < EPSILON);
 }
 function fromUnitVectorToLongLat(out, a) {
-    const len = length(a); // TODO Might drop length check 
+    const len = length(a);
     if (len === 0) {
         throw new Error('Cannot convert a zero vector to unit vector');
     }

package/altitude-locator/plugin.js

@@ -335,7 +335,7 @@ class PointGlowLineToEarthPlugin {
         });
     }
     _doesChanged() {
-        return this._cameraBlockTotem.isMoved() || this._parametersChanged; // TODO: implement
+        return this.globe.api_IsScreenMoving();
     }
     _changed() {
         this._parametersChanged = true;

package/package.json

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

package/point-tracks/plugin.js

@@ -144,7 +144,7 @@ class PointTracksPlugin {
      * @returns
      */
     insertBulk(tracks) {
-        this._fillTracksToPointsMap(tracks); // TODO error should be at the top
+        this._fillTracksToPointsMap(tracks);
         const flattenedPoints = tracks.map(trackToFlatPoints, this._objectStoreExtraParametersFiltered).flat();
         const currentLoad = this._bufferOrchestrator.length;
         if (currentLoad + flattenedPoints.length >= 2147483647) {
@@ -224,7 +224,6 @@ class PointTracksPlugin {
             return;
         this._isFreed = true;
         this._pickerDisplayer.free();
-        this._tracksToPointMap.clear();
         PointOnGlobeProgramCache.release(this.globe);
         this.gl.deleteBuffer(this._focusParams.elementBuffer);
         this._bufferManagersMap.forEach(({ bufferManager, adaptor }) => bufferManager.free());

package/programs/line-on-globe/lines-color-instanced-flat.js

@@ -8,7 +8,6 @@ import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
  * This program draws line between points provided from the first and second buffer.
  * draw method gl.drawArraysInstanced( gl.POINTS, 0,2, lineCount);
  * */
-// TODO: find better way to eleminate edge case distance(posA, posB) > 37000000.0
 const vertexShaderSource = `#version 300 es
 precision highp float;
 ${CameraUniformBlockString}

package/programs/point-on-globe/element-globe-surface-glow.js

@@ -100,7 +100,6 @@ class Logic {
         const vao = gl.createVertexArray();
         const divisor = 1;
         gl.bindVertexArray(vao);
-        // TODO constants to escape values
         attributeLoader(gl, pos3DObj, 0, 3, { divisor });
         attributeLoader(gl, radiusObj, 1, 1, { divisor, escapeValues: [-1] });
         attributeLoader(gl, colorObj, 2, 4, { divisor, escapeValues: [-1, -1, -1, -1] });

package/programs/totems/camerauniformblock.js

@@ -1,6 +1,7 @@
 import { globeProgramCache } from "../programcache";
 import { fromLongLatToUnitVector } from "../../Math/vec3";
 import { RADIANS } from "../../Math/methods";
+import { GlobeChangeObserver } from "./globe-changes";
 export const CameraUniformBlockString = `
 layout(std140) uniform CameraUniformBlock {
     mat4 view; // 64 bytes           0
@@ -29,6 +30,7 @@ export class CameraUniformBlockTotem {
     _isMovedParams;
     _normalizedCameraVector = [0, 0, 0]; // Normalized camera vector
     // _frustumPlanes: any; // Uncomment and type if used
+    _globeChangeObserver = null;
     constructor() {
         this.id = "CameraUniformBlockTotem";
         this.description =
@@ -51,6 +53,7 @@ export class CameraUniformBlockTotem {
         this.ubo = this._createUBO();
         this.traslateFloat32 = new Float32Array(3);
         this.mapWHFloat32 = new Float32Array(2);
+        this._globeChangeObserver = new GlobeChangeObserver(globe);
         this.setGeometry();
         this.resize();
     }
@@ -86,6 +89,7 @@ export class CameraUniformBlockTotem {
         const ubo = this.ubo;
         const mapWHFloat32 = this.mapWHFloat32;
         const globe = this.globe;
+        this._globeChangeObserver?.checkChanges();
         gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
         {
             // view, projection, translate
@@ -196,6 +200,9 @@ export class CameraUniformBlockTotem {
         fromLongLatToUnitVector(result, [CenterLong * RADIANS, CenterLat * RADIANS]);
         return result;
     }
+    getGlobeChanges() {
+        return this._globeChangeObserver?.getChanges();
+    }
     free() {
         const gl = this.gl;
         const ubo = this.ubo;

package/range-tools-on-terrain/bearing-line/plugin.js

@@ -216,7 +216,6 @@ export class BearingLinePlugin {
         this.drawOptions.drawAngleRing = drawAngleRing;
         this.globe.DrawRender();
     }
-    // TODO:
     updatePartial(items, { textWriterIDs } = {}) {
         if (this._freed) {
             throw new Error("Plugin has been freed, cannot update item.");

package/range-tools-on-terrain/circle-line-chain/chain-list-map.js

@@ -1,7 +1,3 @@
-/**
- * set and get node data
- * node indexes;
- */
 export class ChainListMap {
     _chainMap;
     _chainSideProperties;
@@ -98,7 +94,7 @@ export class ChainListMap {
             });
         }
         this._chainMap.delete(chainKey);
-        this._chainSideProperties.delete(chainKey); // TODO: this might be this way but adding this know can cause side effects
+        this._chainSideProperties.delete(chainKey);
         for (const key of keys)
             this._indexMap.delete(key);
         return keys;
@@ -177,10 +173,9 @@ export class ChainListMap {
             memoryProperties[key] = value;
         });
     }
-    // TODO: bad name clean up, need to check on frontend
-    getNodeProperties(chainKey) {
-        return this._chainSideProperties.get(chainKey);
-    }
+    // getNodeProperties(chainKey: string): ChainProperties | undefined {
+    //     return this._chainSideProperties.get(chainKey);
+    // }
     getChainProperties(chainKey) {
         return this._chainSideProperties.get(chainKey);
     }

package/range-tools-on-terrain/circle-line-chain/plugin.js

@@ -158,12 +158,14 @@ export class CircleLineChainPlugin {
         this.globe?.DrawRender();
     }
     setOpacities(opacities) {
-        // TODO: Check opacities
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot set opacities.");
+            return;
+        }
         this._opacities = {
             ...this._opacities,
             ...opacities
         };
-        // set Opacities of plugins
         this.globe?.DrawRender();
     }
     setElevationMode(mode) {

package/semiplugins/shape-on-terrain/padding-1-degree.js

@@ -24,15 +24,14 @@ export class Padding1DegreePlugin {
     bufferOrchestrator;
     bufferManagersMap;
     lineProgram = null;
-    _opacityLODCoef = 1;
-    _pluginOpacity = 1; // this is used to set the opacity of the plugin
     _innerPaddingRatio = 0.9; //
     _float32Array = null; // this is used to forward the data to the buffer manager
     _uboHandler = null; // this is used to forward the data to the shader program
     _bufferNames = ["position2d", "position3d"];
     _vao = null; // this is used to store the VAO for the plugin
     _freed = false; // this is used to check if the plugin is freed or not
-    _lastCAM_LOD = { camInfo: -1, lod: -1 }; // this is used to store the last zoom and lod values
+    _userOpacity = 1;
+    _adaptiveOpacityMultiplier = 1;
     _dataMap = new Map();
     _options = {
         bufferType: "STATIC_DRAW",
@@ -86,7 +85,7 @@ export class Padding1DegreePlugin {
         this.bufferOrchestrator.deleteBulk(keys, this.bufferManagersMap);
         this.globe?.DrawRender();
     }
-    setPluginOpacity(opacity) {
+    setPluginOpacity(opacity, drawRender = false) {
         if (this._freed) {
             console.warn("Plugin is freed, cannot set opacity");
             return;
@@ -96,9 +95,10 @@ export class Padding1DegreePlugin {
             return;
         }
         opacityCheck(opacity);
-        this._opacityLODCoef = opacity;
-        this._uboHandler?.updateSingle("u_opacity", new Float32Array([opacity]));
-        this.globe.DrawRender();
+        this._userOpacity = opacity;
+        if (drawRender) {
+            this.globe.DrawRender();
+        }
     }
     setDefaultColor(color) {
         if (this._freed) {
@@ -143,19 +143,19 @@ export class Padding1DegreePlugin {
                             this._float32Array.fill(NaN); // reset the float32Array
                         }
                         for (let i = 0; i < 360; i++) {
-                            const startCoords = paddingInput.startCoords[i];
-                            const endCoords = paddingInput.endCoords[i];
-                            if (startCoords === null || endCoords === null) {
+                            const outerCoords = paddingInput.outerCoords[i];
+                            const innerCoords = paddingInput.innerCoords[i];
+                            if (outerCoords === null || innerCoords === null) {
                                 continue;
                             }
-                            let coords = globe.api_GetMercator2DPoint(startCoords[0], startCoords[1]);
+                            let coords = globe.api_GetMercator2DPoint(outerCoords[0], outerCoords[1]);
                             // fill the second coordinate with 0
                             this._float32Array[i * 6] = coords[0];
                             this._float32Array[i * 6 + 1] = coords[1];
-                            let innerCoords = globe.api_GetMercator2DPoint(endCoords[0], endCoords[1]);
+                            let coordsInner = globe.api_GetMercator2DPoint(innerCoords[0], innerCoords[1]);
                             // fill the second coordinate with 0
-                            this._float32Array[i * 6 + 2] = innerCoords[0];
-                            this._float32Array[i * 6 + 3] = innerCoords[1];
+                            this._float32Array[i * 6 + 2] = coordsInner[0];
+                            this._float32Array[i * 6 + 3] = coordsInner[1];
                         }
                         return this._float32Array.subarray(0, 360 * 2 * 3);
                     }
@@ -174,22 +174,22 @@ export class Padding1DegreePlugin {
                         }
                         const _float32Array = this._float32Array;
                         for (let i = 0; i < 360; i++) {
-                            const startCoords = paddingInput.startCoords[i];
-                            const endCoords = paddingInput.endCoords[i];
-                            if (startCoords === null || endCoords === null) {
+                            const outerCoords = paddingInput.outerCoords[i];
+                            const innerCoords = paddingInput.innerCoords[i];
+                            if (outerCoords === null || innerCoords === null) {
                                 continue;
                             }
                             const height = paddingInput.heightFromGroundIn3D ?? this._options.defaultHeightFromGroundIn3D;
-                            let coords = globe.api_GetCartesian3DPoint(startCoords[0], startCoords[1], height, this._options.isMSL);
+                            let coords = globe.api_GetCartesian3DPoint(outerCoords[0], outerCoords[1], height, this._options.isMSL);
                             // fill the second coordinate with 0
                             _float32Array[i * 9] = coords[0];
                             _float32Array[i * 9 + 1] = coords[1];
                             _float32Array[i * 9 + 2] = coords[2];
-                            let innerCoords = globe.api_GetCartesian3DPoint(endCoords[0], endCoords[1], height, this._options.isMSL);
+                            let coordsInner = globe.api_GetCartesian3DPoint(innerCoords[0], innerCoords[1], height, this._options.isMSL);
                             // fill the second coordinate with 0
-                            _float32Array[i * 9 + 3] = innerCoords[0];
-                            _float32Array[i * 9 + 4] = innerCoords[1];
-                            _float32Array[i * 9 + 5] = innerCoords[2];
+                            _float32Array[i * 9 + 3] = coordsInner[0];
+                            _float32Array[i * 9 + 4] = coordsInner[1];
+                            _float32Array[i * 9 + 5] = coordsInner[2];
                         }
                         return _float32Array.subarray(0, 360 * 3 * 3);
                     }
@@ -215,11 +215,11 @@ export class Padding1DegreePlugin {
                             this._float32Array[i * 12] = color[0];
                             this._float32Array[i * 12 + 1] = color[1];
                             this._float32Array[i * 12 + 2] = color[2];
-                            this._float32Array[i * 12 + 3] = color[3] * this._opacityLODCoef;
+                            this._float32Array[i * 12 + 3] = color[3];
                             this._float32Array[i * 12 + 4] = color[0];
                             this._float32Array[i * 12 + 5] = color[1];
                             this._float32Array[i * 12 + 6] = color[2];
-                            this._float32Array[i * 12 + 7] = 0; //color[3] * this._opacityLODCoef;
+                            this._float32Array[i * 12 + 7] = 0; //color[3] ;
                         }
                         return this._float32Array.subarray(0, 360 * 4 * 3);
                     }
@@ -233,11 +233,11 @@ export class Padding1DegreePlugin {
                                 this._float32Array[i * 12] = color[0];
                                 this._float32Array[i * 12 + 1] = color[1];
                                 this._float32Array[i * 12 + 2] = color[2];
-                                this._float32Array[i * 12 + 3] = color[3] * this._opacityLODCoef;
+                                this._float32Array[i * 12 + 3] = color[3];
                                 this._float32Array[i * 12 + 4] = color[0];
                                 this._float32Array[i * 12 + 5] = color[1];
                                 this._float32Array[i * 12 + 6] = color[2];
-                                this._float32Array[i * 12 + 7] = 0; // color[3] * this._opacityLODCoef;
+                                this._float32Array[i * 12 + 7] = 0; // color[3] ;
                                 i++;
                             }
                         }
@@ -272,6 +272,9 @@ export class Padding1DegreePlugin {
             console.warn("Globe or LineProgram or VAO is not initialized, cannot draw");
             return;
         }
+        if (this.globe.api_IsScreenMoving()) {
+            this.__build();
+        }
         const gl = this.globe.gl;
         const drawOptions = {
             drawRange: {
@@ -280,7 +283,7 @@ export class Padding1DegreePlugin {
             },
         };
         gl.disable(gl.DEPTH_TEST);
-        this.lineProgram.draw(this._vao, drawOptions, this._pluginOpacity, this._uboHandler);
+        this.lineProgram.draw(this._vao, drawOptions, this._userOpacity * this._adaptiveOpacityMultiplier, this._uboHandler);
         gl.enable(gl.DEPTH_TEST);
     }
     free() {
@@ -310,17 +313,64 @@ export class Padding1DegreePlugin {
         this._innerPaddingRatio = 1 - Math.pow(0.7, lod);
     }
     _buildPaddings(level) {
+        if (level === "input") {
+            // Build input paddings
+        }
+        else if (level === "innerCircle") {
+            // Build inner circle paddings
+            this.__innerCircle();
+            this.__elevation();
+        }
+        else if (level === "elevation") {
+            // Build elevation paddings
+            this.__elevation();
+        }
+    }
+    __innerCircle() {
+        // Implement inner circle padding logic
+        console.log("innerCircle Level Update");
+        const datas = this._dataMap;
+        for (const [key, value] of datas) {
+            // Implement inner circle padding logic using key and value
+            const { innerCoords } = preAdapter(this.globe, value, this._innerPaddingRatio, value.outerCoords);
+            value.innerCoords = innerCoords;
+        }
+    }
+    __elevation() {
+        this._updateAdaptiveOpacityMultiplier();
+        const bufferToUpdate = this.globe?.api_GetCurrentGeometry() === 1 ? "position2d" : "position3d";
+        console.log(bufferToUpdate);
+        const datas = this._dataMap;
+        const wrapper = [null];
+        this._float32Array = new Float32Array(360 * 4 * 4); // largest float32Array
+        for (const [key, value] of datas) {
+            wrapper[0] = value;
+            this.bufferOrchestrator.updateBulk(wrapper, this.bufferManagersMap, [bufferToUpdate]);
+        }
+        this._float32Array = null; // reset the float32Array
+    }
+    __build() {
+        const globeChanges = this.lineProgram?.cameraBlockTotem.getGlobeChanges();
+        if (globeChanges.lodChanged) {
+            console.log("lod changed");
+        }
+        if (globeChanges.lodChanged) {
+            this.__updateLODRelatedParameters();
+            this._buildPaddings("innerCircle");
+        }
+        else if (globeChanges.lookChanged || globeChanges.geometryChanged) {
+            this._buildPaddings("elevation");
+        }
     }
-    __onCamOrLodChange() {
-        //TODO: implement -> on lod change the _innerPaddingRatio and all positions should be recalculated.
-        // calculation
-        // if cam change, recalculate 3d positions
+    _updateAdaptiveOpacityMultiplier() {
+        const currentLod = this.globe?.api_GetCurrentLODWithDecimal();
+        this._adaptiveOpacityMultiplier = Math.max(1 - (2.9 / currentLod), 0.1);
     }
 }
-function preAdapter(globe, paddingInput, paddingRatio, startCoords) {
-    const endCoords = new Array(360);
-    if (startCoords === null) {
-        startCoords = new Array(360);
+function preAdapter(globe, paddingInput, paddingRatio, outerCoords) {
+    const innerCoords = new Array(360);
+    if (outerCoords === null) {
+        outerCoords = new Array(360);
         for (let i = 0; i < 360; i++) {
             const { long, lat } = globe.Math.FindPointByPolar(paddingInput.center[0], // center long
             paddingInput.center[1], // center lat
@@ -333,25 +383,25 @@ function preAdapter(globe, paddingInput, paddingRatio, startCoords) {
             const longDifference = Math.abs(long - endLong);
             const latDifference = Math.abs(lat - endLat);
             if (longDifference > 45) {
-                startCoords[i] = null;
-                endCoords[i] = null;
+                outerCoords[i] = null;
+                innerCoords[i] = null;
                 continue;
             }
             // Assign the calculated coordinates
-            startCoords[i] = [long, lat];
-            endCoords[i] = [endLong, endLat];
+            outerCoords[i] = [long, lat];
+            innerCoords[i] = [endLong, endLat];
         }
     }
     else {
-        // Handle case when startCoords is provided
+        // Handle case when outerCoords is provided
         for (let i = 0; i < 360; i++) {
-            if (startCoords[i] === null) {
-                endCoords[i] = null;
+            if (outerCoords[i] === null) {
+                innerCoords[i] = null;
                 continue;
             }
             const { long: endLong, lat: endLat } = globe.Math.FindPointByPolar(paddingInput.center[0], paddingInput.center[1], paddingInput.outerRadius * paddingRatio, i);
-            endCoords[i] = [endLong, endLat];
+            innerCoords[i] = [endLong, endLat];
         }
     }
-    return { startCoords, endCoords };
+    return { outerCoords, innerCoords };
 }

package/Math/arc-generate-points copy.js

@@ -1,366 +0,0 @@
-// TODO: Delete this file if it is not needed anymore.
-// import { normilze as vec3Normalize, dot as vec3Dot, cross as vec3Cross, scale as vec3Scale, add as vec3Add, sub as vec3Sub } from './vec3';
-// --- Utility Functions for 3D Vector Operations ---
-/**
- * Normalizes a 3D vector to unit length.
- * @param v The input vector.
- * @returns The normalized vector. Returns [0,0,0] if the input vector is a zero vector.
- */
-function vec3Normalize(v) {
-    const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-    if (len < 1e-9) { // Use a small epsilon to handle near-zero vectors
-        return [0, 0, 0];
-    }
-    return [v[0] / len, v[1] / len, v[2] / len];
-}
-/**
- * Calculates the dot product of two 3D vectors.
- * @param v1 The first vector.
- * @param v2 The second vector.
- * @returns The dot product.
- */
-function vec3Dot(v1, v2) {
-    return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
-}
-/**
- * Calculates the cross product of two 3D vectors.
- * @param v1 The first vector.
- * @param v2 The second vector.
- * @returns The cross product vector.
- */
-function vec3Cross(v1, v2) {
-    return [
-        v1[1] * v2[2] - v1[2] * v2[1],
-        v1[2] * v2[0] - v1[0] * v2[2],
-        v1[0] * v2[1] - v1[1] * v2[0]
-    ];
-}
-/**
- * Scales a 3D vector by a scalar.
- * @param v The input vector.
- * @param s The scalar value.
- * @returns The scaled vector.
- */
-function vec3Scale(v, s) {
-    return [v[0] * s, v[1] * s, v[2] * s];
-}
-/**
- * Adds two 3D vectors.
- * @param v1 The first vector.
- * @param v2 The second vector.
- * @returns The resulting vector.
- */
-function vec3Add(v1, v2) {
-    return [v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]];
-}
-/**
- * Subtracts the second 3D vector from the first.
- * @param v1 The first vector.
- * @param v2 The second vector.
- * @returns The resulting vector.
- */
-function vec3Sub(v1, v2) {
-    return [v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]];
-}
-/**
- * Clamps a numerical value within a specified range.
- * @param value The value to clamp.
- * @param min The minimum allowed value.
- * @param max The maximum allowed value.
- * @returns The clamped value.
- */
-function clamp(value, min, max) {
-    return Math.max(min, Math.min(value, max));
-}
-function vec3Distance(v1, v2) {
-    const dx = v1[0] - v2[0];
-    const dy = v1[1] - v2[1];
-    const dz = v1[2] - v2[2];
-    return Math.sqrt(dx * dx + dy * dy + dz * dz);
-}
-/**
- * Rotates a vector around a given axis by a specified angle using Rodrigues' rotation formula.
- * The axis must be a unit vector for correct results.
- * @param v The vector to rotate.
- * @param axis The unit axis of rotation.
- * @param angle The angle of rotation in radians.
- * @returns The rotated vector.
- */
-function rotateVector(v, axis, angle) {
-    const cosAngle = Math.cos(angle);
-    const sinAngle = Math.sin(angle);
-    const oneMinusCos = 1.0 - cosAngle;
-    const dotAxisV = vec3Dot(axis, v);
-    const crossAxisV = vec3Cross(axis, v);
-    // Rodrigues' rotation formula:
-    // v' = v * cos(angle) + (axis x v) * sin(angle) + axis * (axis . v) * (1 - cos(angle))
-    const term1 = vec3Scale(v, cosAngle);
-    const term2 = vec3Scale(crossAxisV, sinAngle);
-    const term3 = vec3Scale(axis, dotAxisV * oneMinusCos);
-    return vec3Add(vec3Add(term1, term2), term3);
-}
-/**
- * Solves a quadratic equation Ax^2 + Bx + C = 0 for x, returning a root within a specified range.
- * Handles linear cases (A approx 0) and multiple roots, selecting the most appropriate one for CDF inversion.
- * @param a Coefficient A.
- * @param b Coefficient B.
- * @param c Coefficient C.
- * @param minVal The minimum expected value for the root.
- * @param maxVal The maximum expected value for the root.
- * @returns The selected root within the range, or null if no valid real root.
- */
-function solveQuadratic(a, b, c, minVal, maxVal) {
-    const epsilon = 1e-12; // Small value for floating point comparisons
-    // Case 1: Linear equation (A is close to zero)
-    if (Math.abs(a) < epsilon) {
-        if (Math.abs(b) < epsilon) {
-            // Both A and B are zero. If C is also zero, infinitely many solutions, pick minVal.
-            // Otherwise, no solutions.
-            return Math.abs(c) < epsilon ? minVal : null;
-        }
-        const x = -c / b;
-        // Check if the linear solution is within the expected range
-        return (x >= minVal - epsilon && x <= maxVal + epsilon) ? x : null;
-    }
-    // Case 2: Quadratic equation
-    const discriminant = b * b - 4 * a * c;
-    if (discriminant < -epsilon) { // No real roots (discriminant is significantly negative)
-        console.log("No real roots for the quadratic equation.");
-        return null;
-    }
-    if (discriminant < epsilon) { // One real root (discriminant is close to zero)
-        const x = -b / (2 * a);
-        return (x >= minVal - epsilon && x <= maxVal + epsilon) ? x : null;
-    }
-    // Case 3: Two distinct real roots
-    const sqrtDisc = Math.sqrt(discriminant);
-    const x1 = (-b + sqrtDisc) / (2 * a);
-    const x2 = (-b - sqrtDisc) / (2 * a);
-    const validX1 = (x1 >= minVal - epsilon && x1 <= maxVal + epsilon);
-    const validX2 = (x2 >= minVal - epsilon && x2 <= maxVal + epsilon);
-    if (validX1 && validX2) {
-        // If both roots are valid, pick the one that is logically correct for CDF inversion.
-        // For an increasing CDF, we generally want the smallest valid non-negative root.
-        return Math.min(x1, x2);
-    }
-    else if (validX1) {
-        return x1;
-    }
-    else if (validX2) {
-        return x2;
-    }
-    else {
-        return null; // No valid roots within the range
-    }
-}
-// --- Main Function for Arc Point Generation ---
-/**
- * Generates points on the shortest arc between p0 and p1 on a unit sphere.
- * The arc is formed by rotating p0 around axisA. The density of points
- * is higher closer to the attractionPoint.
- *
- * @param p0 The starting point of the arc (will be normalized).
- * @param p1 The ending point of the arc (will be normalized).
- * @param axisA The axis of rotation (will be normalized).
- * @param attractionPoint The point on the unit sphere that attracts sampled points (will be normalized).
- * @param pointCount The total number of points to generate on the arc, including p0 and p1.
- * @param strength Controls the density bias. A value of 0 means uniform sampling.
- * Higher positive values (e.g., 1 to 10) result in stronger attraction.
- * @returns An array of `Vec3` representing the deterministically sampled points on the arc.
- */
-export function generateArcPoints(p0, p1, axisA, attractionPoint, pointCount, strength) {
-    const sampledPoints = [];
-    const epsilon = 1e-7; // General epsilon for vector comparisons
-    // 1. Normalize all input vectors
-    let nP0 = vec3Normalize(p0);
-    let nP1 = vec3Normalize(p1);
-    let nAxisA = vec3Normalize(axisA);
-    let nAttractionPoint = vec3Normalize(attractionPoint);
-    // Handle edge cases for pointCount
-    if (pointCount < 1) {
-        return sampledPoints;
-    }
-    if (pointCount === 1) {
-        sampledPoints.push(nP0);
-        return sampledPoints;
-    }
-    // 2. Determine the total rotation angle required to go from p0 to p1 around axisA
-    // Project p0 and p1 onto the plane perpendicular to axisA
-    const p0Projected = vec3Sub(nP0, vec3Scale(nAxisA, vec3Dot(nP0, nAxisA)));
-    const p1Projected = vec3Sub(nP1, vec3Scale(nAxisA, vec3Dot(nP1, nAxisA)));
-    const lenP0Proj = Math.sqrt(vec3Dot(p0Projected, p0Projected));
-    const lenP1Proj = Math.sqrt(vec3Dot(p1Projected, p1Projected));
-    // Handle cases where p0 or p1 are colinear with the rotation axis
-    if (lenP0Proj < epsilon || lenP1Proj < epsilon) {
-        // If start and end points are effectively the same (on or very near the axis)
-        if (Math.abs(vec3Dot(nP0, nP1) - 1.0) < epsilon) {
-            for (let i = 0; i < pointCount; i++) {
-                sampledPoints.push(nP0); // Return identical points as no meaningful arc exists
-            }
-            return sampledPoints;
-        }
-        else {
-            console.warn("generateArcPoints: p0 or p1 is colinear with axisA. Cannot form a valid arc by rotation around axisA to reach p1. Falling back to linear interpolation.");
-            // Fallback: simple linear interpolation and normalize
-            for (let i = 0; i < pointCount; i++) {
-                const t = i / (pointCount - 1);
-                const interpolated = vec3Add(vec3Scale(nP0, (1 - t)), vec3Scale(nP1, t));
-                sampledPoints.push(vec3Normalize(interpolated));
-            }
-            return sampledPoints;
-        }
-    }
-    const nP0Projected = vec3Normalize(p0Projected);
-    const nP1Projected = vec3Normalize(p1Projected);
-    // Calculate total rotation angle using atan2 for a signed angle
-    const crossProj = vec3Cross(nP0Projected, nP1Projected);
-    const totalRotationAngle = Math.atan2(vec3Dot(crossProj, nAxisA), vec3Dot(nP0Projected, nP1Projected));
-    // If total rotation angle is negligible, all points are essentially p0
-    if (Math.abs(totalRotationAngle) < epsilon) {
-        for (let i = 0; i < pointCount; i++) {
-            sampledPoints.push(nP0);
-        }
-        return sampledPoints;
-    }
-    // 3. Find alpha_A: the angle parameter (from p0) where the arc point is closest to attractionPoint
-    // We search over `t` from 0 to 1, and map to actual rotation angles.
-    let alpha_A = 0.0; // This will be the actual rotation angle
-    let minAngleToAttraction = Math.PI; // Initialize with max possible angle
-    // TODO: USE GEOMETRY INSTEAD OF MARKOV CHOICE
-    const testSteps = 1000; // Granularity for finding alpha_A
-    for (let i = 0; i <= testSteps; i++) {
-        const t_test = i / testSteps; // Normalized parameter [0, 1]
-        const currentAlpha = totalRotationAngle * t_test; // Actual rotation angle
-        const pArcTest = rotateVector(nP0, nAxisA, currentAlpha); // Point on arc
-        const dotProduct = clamp(vec3Dot(pArcTest, nAttractionPoint), -1.0, 1.0);
-        const currentAngle = Math.acos(dotProduct);
-        if (currentAngle < minAngleToAttraction) {
-            minAngleToAttraction = currentAngle;
-            alpha_A = currentAlpha;
-        }
-    }
-    // minAngleToAttraction = 0.0;
-    console.log("generated alpha_A:", alpha_A, "minAngleToAttraction:", minAngleToAttraction);
-    // 4. Define the PDF parameters (for normalized parameter t in [0,1])
-    // The density function for 't' (normalized angle from 0 to 1)
-    const minDensity = 1.0;
-    // Strength ensures positive density. Higher strength gives more pronounced peak.
-    const maxDensity = minDensity + Math.max(0, strength);
-    // Normalize alpha_A to the [0, 1] range for the PDF/CDF calculations
-    // This represents the peak position (t_peak) within the normalized parameter space.
-    const alpha_A_normalized = totalRotationAngle !== 0 ? clamp(alpha_A / totalRotationAngle, 0, 1) : 0;
-    // Normalization constant for the PDF (integral over [0,1] must be 1)
-    // Area of trapezoid = 0.5 * (base1 + base2) * height
-    // In our case, the "bases" are minDensity and maxDensity, "height" is 1 (the t-interval length)
-    const pdfArea = 0.5 * (minDensity + maxDensity);
-    const pdfNormalizationConstant = 1.0 / pdfArea;
-    // Calculate CDF value at the peak point (alpha_A_normalized)
-    // This splits the CDF into two regions for the quadratic solver
-    const cdfAtAlphaA_norm = pdfNormalizationConstant * (minDensity * alpha_A_normalized + 0.5 * (maxDensity - minDensity) * alpha_A_normalized);
-    // 5. Generate deterministic points using inverse transform sampling
-    for (let i = 0; i < pointCount; i++) {
-        // Generate uniformly spaced values `u` in [0, 1]
-        const u = i / (pointCount - 1);
-        let t_sampled; // This will be the sampled normalized parameter [0, 1]
-        if (u <= cdfAtAlphaA_norm) {
-            // Case 1: The sampled point falls in the first part of the PDF (0 to alpha_A_normalized)
-            // F(t) = normConst * (minDensity * t + 0.5 * (maxDensity - minDensity) / alpha_A_normalized * t^2)
-            // Rearrange to A*t^2 + B*t + C = 0 for solving:
-            const A = (alpha_A_normalized !== 0) ? pdfNormalizationConstant * 0.5 * (maxDensity - minDensity) / alpha_A_normalized : 0;
-            const B = pdfNormalizationConstant * minDensity;
-            const C = -u;
-            const result = solveQuadratic(A, B, C, 0, alpha_A_normalized);
-            // Fallback for unexpected null (e.g., numerical issues)
-            t_sampled = result !== null ? result : (u / (cdfAtAlphaA_norm || epsilon)) * alpha_A_normalized;
-        }
-        else {
-            // Case 2: The sampled point falls in the second part of the PDF (alpha_A_normalized to 1)
-            // F(t) - cdfAtAlphaA_norm = normConst * [ maxDensity * (t - alpha_A_normalized) - 0.5 * (maxDensity - minDensity) / (1 - alpha_A_normalized) * (t - alpha_A_normalized)^2 ]
-            // Let x = t - alpha_A_normalized. Solve for x: A'*x^2 + B'*x + C' = 0
-            const rangeAfterA = 1 - alpha_A_normalized;
-            const A_prime = (rangeAfterA !== 0) ? -pdfNormalizationConstant * 0.5 * (maxDensity - minDensity) / rangeAfterA : 0;
-            const B_prime = pdfNormalizationConstant * maxDensity;
-            const C_prime = -(u - cdfAtAlphaA_norm);
-            const result_x = solveQuadratic(A_prime, B_prime, C_prime, 0, rangeAfterA);
-            // Fallback for unexpected null
-            t_sampled = (result_x !== null ? alpha_A_normalized + result_x :
-                alpha_A_normalized + (u - cdfAtAlphaA_norm) / ((1 - cdfAtAlphaA_norm) || epsilon) * rangeAfterA);
-        }
-        // Ensure t_sampled is within [0, 1] due to potential float inaccuracies
-        t_sampled = clamp(t_sampled, 0, 1);
-        // Convert the normalized parameter 't_sampled' back to the actual rotation angle
-        const actualRotationAngle = totalRotationAngle * t_sampled;
-        // Rotate the starting point p0 by this angle around axisA to get the final point
-        const currentPoint = rotateVector(nP0, nAxisA, actualRotationAngle);
-        sampledPoints.push(currentPoint);
-    }
-    return sampledPoints;
-}
-// --- Example Usage (for demonstration and testing) ---
-// Example 1: Basic arc, attraction point in the middle
-const p0_ex1 = [1, 0, 0];
-const p1_ex1 = [0, 1, 0]; // 90 deg rotation around Z-axis
-const axisA_ex1 = [0, 0, 1];
-const attractionPoint_ex1 = [Math.sqrt(0.5), Math.sqrt(0.5), 0]; // On the arc, middle of P0-P1
-const numPoints_ex1 = 50;
-const strength_ex1 = 100.0; // Strong attraction
-console.log("--- Example 1: Attraction point in the middle of the arc ---");
-const points1 = generateArcPoints(p0_ex1, p1_ex1, axisA_ex1, attractionPoint_ex1, numPoints_ex1, strength_ex1);
-console.log(`Generated ${points1.length} points.`);
-// To observe concentration, you might visualize these points or calculate their 't' parameter distribution.
-// For console output, let's print a few:
-console.log("First 5 points:", points1.slice(0, 5).map(p => p.map(coord => coord.toFixed(4))));
-console.log("Last 5 points:", points1.slice(-5).map(p => p.map(coord => coord.toFixed(4))));
-// Expected: Points should be denser around [0.707, 0.707, 0]
-const sequentialDistances1 = points1.map((p, i) => {
-    if (i === 0)
-        return 0; // Skip the first point
-    return vec3Distance(points1[i - 1], p);
-});
-console.log("Sequential distances between points (should be roughly equal for uniform distribution):", sequentialDistances1.map(d => d.toFixed(4)));
-// Example 2: Attraction point near p0
-const p0_ex2 = [1, 0, 0];
-const p1_ex2 = [0, 1, 0];
-const axisA_ex2 = [0, 0, 1];
-const attractionPoint_ex2 = [0.99, 0.01, 0]; // Very close to P0
-const numPoints_ex2 = 50;
-const strength_ex2 = 10.0; // Very strong attraction
-console.log("\n--- Example 2: Attraction point near the start (p0) ---");
-const points2 = generateArcPoints(p0_ex2, p1_ex2, axisA_ex2, attractionPoint_ex2, numPoints_ex2, strength_ex2);
-console.log(`Generated ${points2.length} points.`);
-console.log("First 5 points:", points2.slice(0, 5).map(p => p.map(coord => coord.toFixed(4))));
-console.log("Last 5 points:", points2.slice(-5).map(p => p.map(coord => coord.toFixed(4))));
-// Expected: Points should be denser near [1, 0, 0]
-// Example 3: Attraction point away from the arc (expect less concentration)
-const p0_ex3 = [1, 0, 0];
-const p1_ex3 = [0, 1, 0];
-const axisA_ex3 = [0, 0, 1];
-const attractionPoint_ex3 = [0, 0, 1]; // North pole, away from the XY plane arc
-const numPoints_ex3 = 50;
-const strength_ex3 = 5.0;
-console.log("\n--- Example 3: Attraction point away from the arc ---");
-const points3 = generateArcPoints(p0_ex3, p1_ex3, axisA_ex3, attractionPoint_ex3, numPoints_ex3, strength_ex3);
-console.log(`Generated ${points3.length} points.`);
-console.log("First 5 points:", points3.slice(0, 5).map(p => p.map(coord => coord.toFixed(4))));
-console.log("Last 5 points:", points3.slice(-5).map(p => p.map(coord => coord.toFixed(4))));
-// Expected: Points should be relatively uniformly distributed, as no point on the arc is significantly closer.
-// The "closest point" on the arc will likely be determined by its closest angular projection.
-// Example 4: No attraction (uniform distribution)
-const p0_ex4 = [1, 0, 0];
-const p1_ex4 = [0, 1, 0];
-const axisA_ex4 = [0, 0, 1];
-const attractionPoint_ex4 = [Math.sqrt(1 / 2), Math.sqrt(1 / 2), 0]; // Irrelevant when strength is 0
-const numPoints_ex4 = 50;
-const strength_ex4 = 4.0; // No attraction (uniform)
-console.log("\n--- Example 4: Uniform distribution (strength = 0) ---");
-const points4 = generateArcPoints(p0_ex4, p1_ex4, axisA_ex4, attractionPoint_ex4, numPoints_ex4, strength_ex4);
-console.log(`Generated ${points4.length} points.`);
-console.log("First 5 points:", points4.slice(0, 5).map(p => p.map(coord => coord.toFixed(4))));
-console.log("Last 5 points:", points4.slice(-5).map(p => p.map(coord => coord.toFixed(4))));
-// Expected: Points should be uniformly spaced.
-const sequentialDistances = points4.map((p, i) => {
-    if (i === 0)
-        return 0; // Skip the first point
-    return vec3Distance(points4[i - 1], p);
-});
-console.log("Sequential distances between points (should be roughly equal for uniform distribution):", sequentialDistances.map(d => d.toFixed(4)));

package/Math/globe-util/horizon-plane.js

@@ -1,112 +0,0 @@
-"use strict";
-// TODO: REMOVE
-// // import { Vector3D, Quaternion, Plane, Ray, Matrix4 } from 'your-3d-math-library'; // <-- ADAPT THIS IMPORT
-// import { Vector3D } from '../vector3d';
-// import { Plane } from '../plane';
-// import { Line } from '../line';
-// import { Matrix4 } from '../matrix4';
-// import { Quaternion } from '../quaternion';
-// // --- Assume these static helper variables exist within your class ---
-// const _lookFromOrigin = new Vector3D();
-// const _cameraPosition = new Vector3D();
-// const _finalForward = new Vector3D();
-// const _approxUp = new Vector3D();
-// const _finalRight = new Vector3D();
-// const _finalUp = new Vector3D();
-// const _tempVec = new Vector3D(); // General purpose helper
-// const _initialBottomRayDir = new Vector3D();
-// const _qOrient = new Quaternion();
-// const _rollQuaternion = new Quaternion();
-// const _rotationMatrix = new Matrix4();
-// const _fieldOfViewBottomRay = new Line(new Vector3D(), new Vector3D());
-// const _origin3d = new Vector3D(0, 0, 0); // Globe Center
-// // --- Assume these constants exist ---
-// const WORLD_RADIUS_3D = 6371000; // Example: Earth radius
-// const FIELD_OF_VIEW = (25 * Math.PI) / 180; // Example: 25 degrees half-FOV in radians
-// // // --- Assume Plane class has these methods ---
-// // interface Plane {
-// //     setFromNormalAndPoint(normal: Vector3D, point: Vector3D): this;
-// //     set(normal: Vector3D, constant: number): this;
-// //     // ... other plane methods
-// // }
-// // // --- Assume Ray class has these methods ---
-// // interface Ray {
-// //     origin: Vector3D;
-// //     direction: Vector3D;
-// //     intersectionSphere(center: Vector3D, radius: number): Vector3D[] | null; // Or similar
-// //     // ... other ray methods
-// // }
-// // // --- Assume Vector3D has setFromLongLat ---
-// // interface Vector3D {
-// //     setFromLongLat(lon: number, lat: number): this;
-// //     // ... other vector methods
-// // }
-// // // --- END OF ASSUMPTIONS ---
-// /**
-//  * Calculates a culling plane representing the bottom edge of the camera's field of view.
-//  * @param globe - The globe object, expected to have api_GetCurrentLookInfo and Fp properties.
-//  * @param out - The Plane object to store the result.
-//  * @param fieldOfView - The vertical half-angle of the field of view in radians.
-//  * @returns The calculated Plane.
-//  */
-// function calculateHorizonPlane(globe: any, out: Plane, fieldOfView: number = FIELD_OF_VIEW): Plane {
-//     const cameraLookInfo = globe.api_GetCurrentLookInfo();
-//     cameraLookInfo.CenterLong *= Math.PI / 180;
-//     cameraLookInfo.CenterLat *= Math.PI / 180;
-//     // cameraLookInfo.Tilt *= Math.PI / 180; // Tilt is now implicitly handled
-//     cameraLookInfo.NorthAng *= Math.PI / 180;
-//     // Set _lookFromOrigin based on camera target (Lon/Lat)
-//     (_lookFromOrigin as any).setFromLongLat(cameraLookInfo.CenterLong, cameraLookInfo.CenterLat); // Cast to any if setFromLongLat is custom
-//     // 1. Calculate _cameraPosition and _finalForward (_lookFromCamera)
-//     _cameraPosition.set(globe.Fp.x, globe.Fp.y, globe.Fp.z); // Using your X negation
-//     _cameraPosition.divideScalar(WORLD_RADIUS_3D); // Scale to unit sphere
-//     Vector3D.subVectors(_lookFromOrigin, _cameraPosition, _finalForward).normalize();
-//     // 2. Calculate Q_orient (Final Camera Orientation Quaternion)
-//     // Use the vector from origin to camera as an initial 'up' reference
-//     _approxUp.copy(_cameraPosition).normalize();
-//     // Calculate Right vector using cross product
-//     Vector3D.crossVectors(_finalForward, _approxUp, _finalRight).normalize();
-//     // Handle edge case: If looking straight along (or opposite to) _approxUp
-//     if (_finalRight.lengthSq() < 0.0001) {
-//         // If vectors are parallel, _approxUp is not good.
-//         // Choose a different 'up', e.g., if _approxUp is near Z, use Y.
-//         if (Math.abs(_approxUp.z) > 0.9) {
-//             _approxUp.set(0, 1, 0);
-//         } else {
-//             _approxUp.set(0, 0, 1);
-//         }
-//         Vector3D.crossVectors(_finalForward, _approxUp, _finalRight).normalize();
-//     }
-//     // Calculate the 'true' Up vector, orthogonal to Right and Forward
-//     Vector3D.crossVectors(_finalRight, _finalForward, _finalUp).normalize();
-//     // Apply NorthAng (Roll) around the Forward axis
-//     _rollQuaternion.setFromAxisAngle(_finalForward, cameraLookInfo.NorthAng);
-//     _finalUp.applyQuaternion(_rollQuaternion);
-//     _finalRight.applyQuaternion(_rollQuaternion); // Must rotate Right as well!
-//     // Create Q_orient from the final basis vectors (Right, Up, -Forward)
-//     // This assumes a Matrix4.makeBasis(x, y, z) exists and builds a rotation matrix.
-//     // It also assumes local camera looks down -Z, hence negating _finalForward for the Z basis.
-//     _tempVec.copy(_finalForward).negate();
-//     _rotationMatrix.makeBasis(_finalRight, _finalUp, _tempVec); // <-- ADAPT: Ensure your library has makeBasis or equivalent
-//     _qOrient.setFromRotationMatrix(_rotationMatrix); // <-- ADAPT: Ensure this function exists
-//     // 3. Calculate Initial Bottom Ray (Local: -Z forward, Y up, X right)
-//     // Rotates (0, 0, -1) around (1, 0, 0) by fieldOfView
-//     _initialBottomRayDir.set(0, -Math.sin(fieldOfView), -Math.cos(fieldOfView));
-//     // 4. Calculate Final Bottom Ray (World)
-//     _fieldOfViewBottomRay.direction.copy(_initialBottomRayDir).applyQuaternion(_qOrient).normalize();
-//     _fieldOfViewBottomRay.origin.copy(_cameraPosition);
-//     // 5. Intersection and Plane
-//     const intersection = (_fieldOfViewBottomRay as any).intersectionSphere(_origin3d, 1); // Cast to any if method isn't standard
-//     if (intersection && intersection.length > 0) {
-//         // If ray intersects, use the closest point for the plane
-//         out.setFromNormalAndPoint(_lookFromOrigin, intersection[0]);
-//     } else {
-//         // If ray does not intersect (FOV covers globe or misses)
-//         // WARNING: This sets a plane through the globe's center.
-//         // This might not be the desired behavior for culling.
-//         // Consider what should happen if the whole globe *is* visible.
-//         out.set(_lookFromOrigin, 0.0);
-//     }
-//     return out;
-// }
-// export { calculateHorizonPlane };

package/altitude-locator/draw-subset-obj.js

@@ -1,16 +0,0 @@
-import "./types";
-/**
- * @param {DrawSubsetOptions} drawSubsetOptions
- */
-// TODO: Draw all is an optional property for the target plugin, with this approach.
-class DrawSubsetOptionRegistry {
-    constructor() {
-        this._drawSubsetOptions = new Map();
-    }
-    register(key, drawSubsetOptions) {
-        this._drawSubsetOptions.set(key, drawSubsetOptions);
-    }
-    unregister(key) {
-        this._drawSubsetOptions.delete(key);
-    }
-}

package/semiplugins/shape-on-terrain/derived/padding-plugin.js

@@ -1,101 +0,0 @@
-import { ArcOnTerrainPlugin } from "../arc-plugin";
-const EDGE_COUNT = 5;
-const paddingKeys = (padding) => {
-    const stepCount = padding.coverAngle / padding.stepAngle;
-    const keys = new Array(Math.ceil(stepCount));
-    for (let i = 0; i < stepCount; i++) {
-        keys[i] = padding.key + i;
-    }
-    if (keys.length > stepCount) {
-        keys[keys.length - 1] = padding.key + stepCount;
-    }
-    return keys;
-};
-const adapterPadding2Arc = (globe, padding) => {
-    const stepCount = padding.coverAngle / padding.stepAngle;
-    const result = new Array(Math.ceil(stepCount));
-    const fill = (i, angle) => {
-        const startPoint = globe.Math.FindPointByPolar(padding.center[0], padding.center[1], padding.outerRadius, angle);
-        const endPoint = globe.Math.FindPointByPolar(padding.center[0], padding.center[1], padding.innerRadius, angle);
-        result[i] = {
-            key: padding.key + i,
-            start: [startPoint.long, startPoint.lat],
-            end: [endPoint.long, endPoint.lat],
-            color: padding.color,
-            height: padding.height,
-        };
-    };
-    for (let i = 0; i < stepCount; i++) {
-        const angle = padding.startAngle + i * padding.stepAngle;
-        fill(i, angle);
-    }
-    if (result.length > stepCount) {
-        const i = result.length - 1;
-        const angle = padding.startAngle + padding.coverAngle;
-        fill(i, angle);
-    }
-    return result;
-};
-export const chargerAdaptor = (chargerInput, plugin, padding) => {
-};
-export class PaddingPlugin {
-    id;
-    arcPlugin;
-    globe = null;
-    _memory = new Map();
-    isFreed = false;
-    constructor(id, { variativeColorsOn = true, defaultColor = [1, 1, 1, 1], defaultHeightFromGroundIn3D = 30.0, vertexCount = EDGE_COUNT } = {}) {
-        this.id = id;
-        this.arcPlugin = new ArcOnTerrainPlugin(id, {
-            cameraAttractionIsOn: false,
-            vertexCount: vertexCount,
-            variativeColorsOn: variativeColorsOn,
-            defaultColor: defaultColor,
-            defaultHeightFromGroundIn3D: defaultHeightFromGroundIn3D,
-        });
-    }
-    insertBulk(items) {
-        for (const padding of items) {
-            this.__delete(padding.key);
-            this._memory.set(padding.key, padding);
-        }
-        const arcInputs = items.flatMap(padding => adapterPadding2Arc(this.globe, padding));
-        this.arcPlugin.insertBulk(arcInputs);
-    }
-    deleteBulk(keys) {
-        const arcKeys = keys.flatMap(key => paddingKeys({ key, center: [0, 0], outerRadius: 0, innerRadius: 0, startAngle: 0, coverAngle: 0, stepAngle: 0, color: [0, 0, 0, 1] }));
-        this.arcPlugin.deleteBulk(arcKeys);
-    }
-    updateColor(key, color) {
-        // TODO: get all padding keys and update all of them
-        if (!this._memory.has(key)) {
-            console.warn(`Padding with key ${key} does not exist.`);
-            return;
-        }
-        const keys = paddingKeys(this._memory.get(key));
-        for (let i = 0; i < keys.length; i++) {
-            this.arcPlugin.updateColor(keys[i], color);
-        }
-    }
-    __delete(key) {
-        const padding = this._memory.get(key);
-        if (padding) {
-            const keys = paddingKeys(padding);
-            this.arcPlugin.deleteBulk(keys);
-            this._memory.delete(key);
-        }
-    }
-    init(globe, gl) {
-        this.globe = globe;
-        this.arcPlugin.init(globe, gl);
-    }
-    draw3D() {
-        this.arcPlugin.draw3D();
-    }
-    free() {
-        if (this.isFreed)
-            return;
-        this.isFreed = true;
-        this.arcPlugin.free();
-    }
-}