@pirireis/webglobeplugins 1.0.3 → 1.0.4

package/{vectorfield → webglobeplugins/vectorfield}/waveparticles/plugin.js

@@ -1,3 +1,6 @@
+/**
+ * Author: Toprak Nihat Deniz Ozturk
+ */
 import { BBOXGlobeShell } from "../../semiplugins/shell/bbox-renderer/index";
 import { defaultblendfunction } from "../../util/globe-default-gl-states";
 import { PingPongBufferManager } from "../../programs/vectorfields/pingpongbuffermanager";
@@ -5,6 +8,8 @@ import { pixelBasedMoveProgramCache } from "../../programs/vectorfields/logics/p
 import { drawRectangleParticlesProgramCache } from "../../programs/vectorfields/logics/drawrectangleparticles";
 import { FadeAwayProgramCache } from "../../programs/helpers/fadeaway";
 import { ParticleUBO } from "../../programs/vectorfields/logics/particle-ubo";
+import { isBoolean } from "../../util/check/typecheck";
+import { AdaptiveOpacityAttachmentObserver, } from "../../programs/totems/attachments/adaptive-opacity";
 /**
  * STEPS:
  * 1. move particle | buffers: read b1 write b2 | swap buffers b1 <-> b2
@@ -15,7 +20,31 @@ import { ParticleUBO } from "../../programs/vectorfields/logics/particle-ubo";
 const MAX_PIXELS_ON_DIMENSION = 2200;
 export default class Plugin {
     id;
-    options;
+    options = {
+        tailSize: 1.0,
+        wingSize: 7.0,
+        dataWidth: 256,
+        dataHeight: 256,
+        fadeOpacity: 0.83,
+        opacity: 0.75,
+        speed: 0.6,
+        dropRate: 0.007,
+        height: 0,
+        minLon: -180,
+        minLat: -90,
+        maxLon: 180,
+        maxLat: 90,
+        particleCount: 4000,
+        flipY: true,
+        drawTextureMaxPixelOnDimension: MAX_PIXELS_ON_DIMENSION,
+        useColorTexture: false,
+        initialColorData: null,
+        useSpeedTexture: false,
+        initialSpeedTexture: null,
+        minSpeedThreshold: 0.0,
+        maxSpeedThreshold: 150.9,
+        adaptiveOpacityOn: false,
+    };
     globe;
     gl;
     moveParticle;
@@ -37,34 +66,12 @@ export default class Plugin {
     _colorFieldTexture = null;
     _initialColorFieldData = null;
     _speedFieldTexture = null;
+    _ableToUseSpeedField = false;
     _initialSpeedFieldData = null;
+    __adaptiveOpacity = 1;
     constructor(id, options) {
         this.id = id;
-        this.options = {
-            tailSize: options.tailSize || 1.0,
-            wingSize: options.wingSize || 7.0,
-            dataWidth: options.dataWidth || 256,
-            dataHeight: options.dataHeight || 256,
-            fadeOpacity: options.fadeOpacity ?? 0.83,
-            opacity: options.opacity ?? 0.75,
-            speed: options.speed ?? 0.6,
-            dropRate: options.dropRate ?? 0.007,
-            height: options.height ?? 0,
-            minLon: options.minLon ?? -180,
-            minLat: options.minLat ?? -90,
-            maxLon: options.maxLon ?? 180,
-            maxLat: options.maxLat ?? 90,
-            particleCount: options.particleCount ?? 8000,
-            flipY: options.flipY ?? true,
-            drawTextureMaxPixelOnDimension: options.drawTextureMaxPixelOnDimension ?? MAX_PIXELS_ON_DIMENSION,
-            useColorTexture: options.useColorTexture ?? false,
-            initialColorData: options.initialColorData ?? null,
-            useSpeedTexture: options.useSpeedTexture ?? false,
-            initialSpeedTexture: options.initialSpeedTexture ?? null,
-            minSpeedThreshold: options.minSpeedThreshold ?? 0.0,
-            maxSpeedThreshold: options.maxSpeedThreshold ?? 150.9,
-        };
-        console.log("WaveParticle options:", this.options);
+        this.options = { ...this.options, ...options };
         this._drawTextureResolution = {};
         this._globeshellparameters = {
             minLon: this.options.minLon,
@@ -83,6 +90,12 @@ export default class Plugin {
     init(globe, gl) {
         this.globe = globe;
         this.gl = gl;
+        if (gl.getExtension("OES_texture_float_linear")) {
+            this._ableToUseSpeedField = true;
+        }
+        else {
+            console.log("unable to use OES_texture_float_linear extension, speed field texture disabled");
+        }
         this.moveParticle = pixelBasedMoveProgramCache.getProgram(gl);
         this.drawParticle = drawRectangleParticlesProgramCache.getProgram(gl);
         this.fadeAway = FadeAwayProgramCache.get(gl);
@@ -91,7 +104,7 @@ export default class Plugin {
         this.bufferManager = new PingPongBufferManager(gl, this.options.particleCount, inPositionLocation);
         this._rgVectorFieldTexture = this._createRGTexture();
         this.waveUbo = ParticleUBO.createUBO(gl);
-        if (this.options.useColorTexture) {
+        if (this.options.useColorTexture && this._ableToUseSpeedField) {
             this.waveUbo.updateSingle("use_color_field", new Float32Array([1]));
             if (this._initialColorFieldData) {
                 this.setColorField(this._initialColorFieldData);
@@ -102,7 +115,7 @@ export default class Plugin {
             }
         }
         if (this.options.useSpeedTexture) {
-            this.waveUbo.updateSingle("use_speed_field", new Float32Array([1]));
+            this.waveUbo.updateSingle("use_magnitude_field", new Float32Array([1]));
             console.log("use speed texture");
             if (this._initialSpeedFieldData) {
                 this.setSpeedField(this._initialSpeedFieldData);
@@ -121,7 +134,9 @@ export default class Plugin {
         this.setDropRate(this.options.dropRate);
         this.setHeight(this.options.height);
         // ensure speed thresholds are applied to UBO on init
-        this.setSpeedThresholds(this.options.minSpeedThreshold, this.options.maxSpeedThreshold);
+        this.setMinSpeedThreshold(this.options.minSpeedThreshold);
+        this.setMaxSpeedThreshold(this.options.maxSpeedThreshold);
+        this.setCycleStepCount(3);
         this.____drawIndex = 0;
     }
     draw3D() {
@@ -197,6 +212,7 @@ export default class Plugin {
             gl.deleteTexture(this._speedFieldTexture);
             this._speedFieldTexture = null;
         }
+        AdaptiveOpacityAttachmentObserver.unsubscribe(this);
     }
     setParticleCount(value) {
         this.options.particleCount = value;
@@ -214,7 +230,6 @@ export default class Plugin {
         const { gl } = this;
         if (!gl || !this._rgVectorFieldTexture)
             return;
-        console.log("flipY:", this.options.flipY);
         gl.bindTexture(gl.TEXTURE_2D, this._rgVectorFieldTexture);
         gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, this.options.flipY);
         gl.texImage2D(gl.TEXTURE_2D, 0, gl.RG32F, this.options.dataWidth, this.options.dataHeight, 0, gl.RG, gl.FLOAT, data);
@@ -255,7 +270,8 @@ export default class Plugin {
             console.error("Opacity must be a number between 0 and 1");
             return;
         }
-        this.globeShellWiggle?.setOpacity(value);
+        this.options.opacity = value;
+        this.globeShellWiggle?.setOpacity(value * this.__adaptiveOpacity);
     }
     setParticleDimensions(tail, wing) {
         if (0 < tail && 0 < wing) {
@@ -293,12 +309,21 @@ export default class Plugin {
         gl.bindTexture(gl.TEXTURE_2D, this._colorFieldTexture);
         gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, this.options.flipY);
         gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, this.options.dataWidth, this.options.dataHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
         gl.bindTexture(gl.TEXTURE_2D, null);
     }
+    setUseSpeedField(use) {
+        isBoolean(use);
+        if (!this.waveUbo) {
+            console.warn("UBO is not initialized yet.");
+            return;
+        }
+        this.options.useSpeedTexture = use;
+        this.waveUbo.updateSingle("use_magnitude_field", new Float32Array([use ? 1 : 0]));
+    }
     setSpeedField(data) {
         const { gl } = this;
         if (!gl)
@@ -318,8 +343,8 @@ export default class Plugin {
         gl.bindTexture(gl.TEXTURE_2D, this._speedFieldTexture);
         gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, this.options.flipY);
         gl.texImage2D(gl.TEXTURE_2D, 0, gl.R32F, this.options.dataWidth, this.options.dataHeight, 0, gl.RED, gl.FLOAT, data);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
         gl.bindTexture(gl.TEXTURE_2D, null);
@@ -329,11 +354,12 @@ export default class Plugin {
      */
     setMinSpeedThreshold(value) {
         this.options.minSpeedThreshold = value;
-        this.waveUbo?.updateSingle("min_speed_threshold", new Float32Array([value]));
+        this.waveUbo?.updateSingle("min_magnitude_threshold", new Float32Array([value]));
     }
     setMaxSpeedThreshold(value) {
+        console.log("setMaxSpeedThreshold called with value:", value);
         this.options.maxSpeedThreshold = value;
-        this.waveUbo?.updateSingle("max_speed_threshold", new Float32Array([value]));
+        this.waveUbo?.updateSingle("max_magnitude_threshold", new Float32Array([value]));
     }
     setSpeedThresholds(min, max) {
         this.setMinSpeedThreshold(min);
@@ -358,6 +384,10 @@ export default class Plugin {
         this._rgVectorFieldTexture = this._createRGTexture();
         this.setVectorFieldData(textureData);
     }
+    __adaptiveOpacity_set(value) {
+        this.__adaptiveOpacity = value;
+        this.globeShellWiggle?.setOpacity(this.options.opacity * this.__adaptiveOpacity);
+    }
     _drawTextureSizeFromBbox({ minLon, minLat, maxLon, maxLat }) {
         let horizon;
         if (minLon > 0 && maxLon < 0) {
@@ -409,6 +439,16 @@ export default class Plugin {
         gl.bindTexture(gl.TEXTURE_2D, null);
         return texture;
     }
+    setAdaptiveOpacityOn(value) {
+        isBoolean(value);
+        this.options.adaptiveOpacityOn = value;
+        if (value) {
+            AdaptiveOpacityAttachmentObserver.subscribe(this);
+        }
+        else {
+            AdaptiveOpacityAttachmentObserver.unsubscribe(this);
+        }
+    }
     _step() {
         this._stepIndex = (this._stepIndex + 1) % this._fullCycleStepCount;
     }

package/{vectorfield → webglobeplugins/vectorfield}/wind/adapters/image-to-fields.js

@@ -1,3 +1,6 @@
+/**
+ * Author: Toprak Nihat Deniz Ozturk
+ */
 export function imageToFields(data, legendData) {
     const { image, uMin, vMin, uMax, vMax } = data;
     const width = image.width;
@@ -33,27 +36,55 @@ export function imageToFields(data, legendData) {
             const r = imageData.data[index];
             const g = imageData.data[index + 1];
             // Map texel [0,255] to actual speed values [uMin,uMax] and [vMin,vMax]
-            const uSpeed = uMin + (r / 255) * uDiff;
-            const vSpeed = vMin + (g / 255) * vDiff;
-            // Normalize to [-1,1] range for vector field
             const u = uMin + (uDiff * r) / 255;
             const v = vMin + (vDiff * g) / 255;
+            const speed = Math.sqrt(u * u + v * v);
+            speedFieldData[y * width + x] = speed;
             vectorFieldData[(y * width + x) * 2] = u / scaler;
             vectorFieldData[(y * width + x) * 2 + 1] = -v / scaler;
-            const speed = Math.sqrt(uSpeed * uSpeed + vSpeed * vSpeed);
-            speedFieldData[y * width + x] = speed;
-            // Determine color based on speed and legendData
-            let colorIndex = legendData.thresholds.length - 1;
-            for (let i = 0; i < legendData.thresholds.length; i++) {
-                if (speed < legendData.thresholds[i]) {
-                    colorIndex = i;
-                    break;
+            // Determine color via linear interpolation between thresholds
+            const thresholds = legendData.thresholds;
+            const n = Math.min(thresholds.length, parsedColors.length);
+            let outR = 0, outG = 0, outB = 0;
+            if (n === 0) {
+                outR = outG = outB = 0;
+            }
+            else if (n === 1 || speed <= thresholds[0]) {
+                outR = parsedColors[0].r;
+                outG = parsedColors[0].g;
+                outB = parsedColors[0].b;
+            }
+            else if (speed >= thresholds[n - 1]) {
+                outR = parsedColors[n - 1].r;
+                outG = parsedColors[n - 1].g;
+                outB = parsedColors[n - 1].b;
+            }
+            else {
+                let i = 0;
+                for (; i < n - 1; i++) {
+                    if (speed < thresholds[i + 1])
+                        break;
+                }
+                if (i === n - 1) {
+                    // set to last color
+                    outR = parsedColors[n - 1].r;
+                    outG = parsedColors[n - 1].g;
+                    outB = parsedColors[n - 1].b;
+                    continue;
                 }
+                const t0 = thresholds[i];
+                const t1 = thresholds[i + 1];
+                const denom = t1 - t0 || 1;
+                const t = Math.max(0, Math.min(1, (speed - t0) / denom));
+                const c0 = parsedColors[i];
+                const c1 = parsedColors[i + 1];
+                outR = Math.round(c0.r + (c1.r - c0.r) * t);
+                outG = Math.round(c0.g + (c1.g - c0.g) * t);
+                outB = Math.round(c0.b + (c1.b - c0.b) * t);
             }
-            const color = parsedColors[colorIndex];
-            colorFieldData[index] = color.r;
-            colorFieldData[index + 1] = color.g;
-            colorFieldData[index + 2] = color.b;
+            colorFieldData[index] = outR;
+            colorFieldData[index + 1] = outG;
+            colorFieldData[index + 2] = outB;
             colorFieldData[index + 3] = 255; // Alpha channel
         }
     }

package/{vectorfield → webglobeplugins/vectorfield}/wind/plugin-persistant.js

@@ -43,6 +43,7 @@ export default class WindPlugin {
     _dropRate;
     texturePointSampler;
     texturePointSamplerAngle;
+    adaptiveOpacityOn = false;
     /**
      * @param id - Plugin identifier
      * @param windDataMeta - Wind data metadata
@@ -68,18 +69,19 @@ export default class WindPlugin {
         this.windMetadata = windDataMeta;
         this._legendData = options.legendData || windyLegendData;
         this.options = {
-            fadeOpacity: options.fadeOpacity ?? 0.746,
-            speedFactor: options.speedFactor ?? 0.6,
-            dropRate: options.dropRate ?? 0.007,
-            dropRateBump: options.dropRateBump ?? 0.001,
+            fadeOpacity: options.fadeOpacity ?? 0.91,
+            speedFactor: options.speedFactor ?? 1,
+            dropRate: options.dropRate ?? 0.06,
+            // dropRateBump: options.dropRateBump ?? 0.001,
             baseOpacity: options.baseOpacity ?? 1.0,
-            wingSize: options.wingSize ?? 7.0,
-            tailSize: options.tailSize ?? 1.0,
+            wingSize: options.wingSize ?? 2.0,
+            tailSize: options.tailSize ?? 10.0,
             minSpeed: options.minSpeed ?? 0.0,
             maxSpeed: options.maxSpeed ?? 1000.0,
             height: options.height ?? 0.0,
             numParticles: options.numParticles ?? 40000,
-            legendData: this._legendData
+            legendData: this._legendData,
+            adaptiveOpacityOn: options.adaptiveOpacityOn ?? false
         };
         this.windData = null;
         this._height = this.options.height;
@@ -106,7 +108,7 @@ export default class WindPlugin {
             maxLat: bbox[3] > 85 ? 85 : bbox[3],
             particleCount: this.options.numParticles,
             flipY: flipY ?? true,
-            useColorTexture: false, // TODO: under test.. make it true later
+            useColorTexture: true, // TODO: under test.. make it true later
             useSpeedTexture: true,
             minSpeedThreshold: this.options.minSpeed,
             maxSpeedThreshold: this.options.maxSpeed,
@@ -197,11 +199,17 @@ export default class WindPlugin {
     }
     setFlipY(flipY) {
         isBoolean(flipY);
-        this.windMetadata.flipY = flipY;
         if (this.particlePlugin && this.windData) {
+            this.windMetadata.flipY = flipY;
             this.setWind(this.windData);
         }
     }
+    setUseSpeedField(use) {
+        if (this.particlePlugin) {
+            console.log("use speed field set to ", use);
+            this.particlePlugin.setUseSpeedField(use);
+        }
+    }
     setDrawTextureMaxPixelOnDimension(value) {
         if (this.particlePlugin) {
             this.particlePlugin.setDrawTextureMaxPixelOnDimension(value);
@@ -220,6 +228,7 @@ export default class WindPlugin {
     set minSpeed(value) {
         this.options.minSpeed = value;
         if (this.particlePlugin) {
+            console.log("value", value);
             this.particlePlugin.setMinSpeedThreshold(value);
         }
     }
@@ -262,14 +271,6 @@ export default class WindPlugin {
     get dropRate() {
         return this._dropRate;
     }
-    set dropRateBump(value) {
-        this.options.dropRateBump = value;
-        // Note: ParticlePlugin doesn't have dropRateBump parameter
-        // This would need to be added to ParticlePlugin if needed
-    }
-    get dropRateBump() {
-        return this.options.dropRateBump;
-    }
     set baseOpacity(value) {
         this.options.baseOpacity = value;
         if (this.particlePlugin) {
@@ -288,6 +289,13 @@ export default class WindPlugin {
     get numParticles() {
         return this.options.numParticles;
     }
+    set adaptiveOpacity(value) {
+        this.adaptiveOpacityOn = value;
+        this.particlePlugin.setAdaptiveOpacityOn(value);
+    }
+    get adaptiveOpacity() {
+        return this.adaptiveOpacityOn;
+    }
     /**
      * Set wing and tail size for particle arrows
      */
@@ -322,6 +330,13 @@ export default class WindPlugin {
         // Update metadata
         this.windMetadata.bbox = [bbox.minLon, bbox.minLat, bbox.maxLon, bbox.maxLat];
     }
+    setAdaptiveOpacityOn(value) {
+        isBoolean(value);
+        this.adaptiveOpacityOn = value;
+        if (this.particlePlugin) {
+            this.particlePlugin.setAdaptiveOpacityOn(value);
+        }
+    }
     // ===== Texture Point Sampler (for backward compatibility) =====
     /**
      * Get texture point sampler for magnitude or angle

package/{vectorfield → webglobeplugins/vectorfield}/wind/plugin.js

@@ -504,20 +504,20 @@ export default class WindPlugin {
         const windDataMeta = this._windDataMeta;
         const gl = this.gl;
         this.windData = windData;
-        this.windTexture = createTexture(gl, gl.LINEAR, windData.image);
+        this.windTexture = createTexture(gl, gl.NEAREST, windData.image);
         const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(this.updateProgram.program);
         gl.uniform2f(this.updateProgram.u_wind_res, windDataMeta.width, windDataMeta.height);
         gl.uniform2f(this.updateProgram.u_wind_min, this.windData.uMin, this.windData.vMin);
         gl.uniform2f(this.updateProgram.u_wind_max, this.windData.uMax, this.windData.vMax);
         this.setGeometry();
-        console.log("windData bbox", windData.bbox);
         const minXY = this._latLongToPixelXY(windDataMeta.bbox[1], windDataMeta.bbox[0]);
         const maxXY = this._latLongToPixelXY(windDataMeta.bbox[3], windDataMeta.bbox[2]);
         this._loadBoundingBoxData(minXY.x, minXY.y, maxXY.x, maxXY.y);
         gl.useProgram(currentProgram);
         this._setCoorcinatesDataCalculatorData();
-        this.resize();
+        // this.resize();
+        this.globe.DrawRender();
     }
     // Vector field texture is used to calculate the particle movement.
     /**
@@ -757,7 +757,7 @@ export default class WindPlugin {
             alert("Geometry is not supported");
         }
         gl.useProgram(currentProgram);
-        this.resize();
+        // this.resize();
     }
     _updateParticles() {
         const gl = this.gl;

package/semiplugins/shape-on-terrain/terrain-polygon/data/polygon-to-triangles.js

@@ -1,100 +0,0 @@
-/**
- * # Purpose
- * Divide long edges of polygons into smaller segments
- *
- * This algorithm should be called after earcutting / triangulation.
- * Then earcut should run second time to further divide long edges.
- *
- * populate points on a arc between two given points on a sphere
- *
- */
-import { haversine } from "../../../../Math/haversine";
-import earcut from "earcut";
-/**
- *
- */
-function __pointsInBetweenGreateCircle(lat1, lon1, lat2, lon2, unitSphereDistance) {
-    const points = [];
-    const d1 = haversine(lat1, lon1, lat2, lon2);
-    if (d1 <= unitSphereDistance) {
-        return null;
-    }
-    const numSegments = Math.ceil(d1 / unitSphereDistance);
-    for (let i = 1; i < numSegments; i++) {
-        const f = i / numSegments;
-        const A = Math.sin((1 - f) * d1) / Math.sin(d1);
-        const B = Math.sin(f * d1) / Math.sin(d1);
-        const x = A * Math.cos(lat1) * Math.cos(lon1) + B * Math.cos(lat2) * Math.cos(lon2);
-        const y = A * Math.cos(lat1) * Math.sin(lon1) + B * Math.cos(lat2) * Math.sin(lon2);
-        const z = A * Math.sin(lat1) + B * Math.sin(lat2);
-        const latN = Math.atan2(z, Math.sqrt(x * x + y * y));
-        const lonN = Math.atan2(y, x);
-        points.push(latN, lonN);
-    }
-    return points;
-}
-function _dividePolygonEdgeSize(polygon, kmThreshold) {
-    const unitSphereDistance = kmThreshold / 6371; // Earth radius in km
-    const newGeometries = polygon.geometry.map(geom => {
-        const { vertices, holes } = geom;
-        const newVertices = [];
-        const newHoles = [];
-        const processRing = (start, end) => {
-            for (let i = start; i < end; i++) {
-                const long1 = vertices[2 * i];
-                const lat1 = vertices[2 * i + 1];
-                const next_i = (i + 1 < end) ? i + 1 : start;
-                const long2 = vertices[2 * next_i];
-                const lat2 = vertices[2 * next_i + 1];
-                newVertices.push(long1, lat1);
-                const extraPoints = __pointsInBetweenGreateCircle(lat1, long1, lat2, long2, unitSphereDistance);
-                if (extraPoints) {
-                    newVertices.push(...extraPoints);
-                }
-            }
-        };
-        const shellEnd = holes.length > 0 ? holes[0] : vertices.length / 2;
-        processRing(0, shellEnd);
-        for (let h = 0; h < holes.length; h++) {
-            newHoles.push(newVertices.length / 2);
-            const holeStart = holes[h];
-            const holeEnd = h + 1 < holes.length ? holes[h + 1] : vertices.length / 2;
-            processRing(holeStart, holeEnd);
-        }
-        return { vertices: newVertices, holes: newHoles };
-    });
-    return {
-        ...polygon,
-        geometry: newGeometries,
-    };
-}
-// TODO: 
-// divide TrianglesMiddleData edges longer than threshold
-// function _divideTriangleEdges(
-//     key: string,
-//     vertices: number[],
-//     indices: number[],
-//     kmThreshold: number // maybe
-// ): TrianglesMiddleData {
-//     return { key, vertices, indices };
-// }
-// TODO: NEED TEST
-function triangulation(polygon, kmThreshold) {
-    const finalVertices = [];
-    const finalIndices = [];
-    let vertexIndexOffset = 0;
-    for (const geom of polygon.geometry) {
-        const indices = earcut(geom.vertices, geom.holes, 2);
-        finalVertices.push(...geom.vertices);
-        for (const index of indices) {
-            finalIndices.push(index + vertexIndexOffset);
-        }
-        vertexIndexOffset += geom.vertices.length / 2;
-    }
-    return {
-        key: polygon.key,
-        vertices: finalVertices,
-        indices: finalIndices
-    };
-}
-export { triangulation };

package/semiplugins/shape-on-terrain/terrain-polygon/data/worker.js

@@ -1,125 +0,0 @@
-/// <reference lib="webworker" />
-import { Cache } from "./cache";
-import { partialTessellation, zoomLevelShowThreshold } from "../../../../Math/tessellation/triangle-tessellation";
-import { IndexAttributeEscapeValue } from "../../../../programs/polygon-on-globe/texture-dem-triangles";
-const cache = new Cache(100); // 100 km threshold
-let _pickableState = false;
-let _variativeColorsOnState = false;
-let showThreshold = 0;
-// eslint-disable-next-line no-restricted-globals
-self.onmessage = (event) => {
-    try {
-        const { bboxes, insertDeleteQueue, pickableState, variativeColorsOn } = event.data;
-        if (variativeColorsOn !== undefined) {
-            _variativeColorsOnState = variativeColorsOn;
-        }
-        if (pickableState !== undefined) {
-            _pickableState = pickableState;
-        }
-        // Process insert/delete queue
-        if (insertDeleteQueue[0] === "__CLEAR_ALL_ITEMS__") {
-            insertDeleteQueue.shift();
-            cache.clear();
-        }
-        for (const item of insertDeleteQueue) {
-            if (typeof item === 'string') {
-                cache.remove(item);
-            }
-            else {
-                cache.insert(item.key, item);
-            }
-        }
-        // Update bboxes if provided
-        if (bboxes) {
-            cache.setBBOXes(bboxes);
-            showThreshold = zoomLevelShowThreshold(bboxes[0].zoom, 0.03);
-        }
-        // Search for triangles in view
-        const trianglesInView = cache.search();
-        // Prepare arrays for merging
-        const results = [];
-        // Convert bbox to BBoxZoom format for partialTessellation
-        const bboxZooms = bboxes ? bboxes.map(b => ({
-            bbox: {
-                min: [b.minX, b.minY],
-                max: [b.maxX, b.maxY]
-            },
-            zoom: b.zoom
-        })) : []; // This will be empty if no bbox, causing issues
-        let counter = 0;
-        let indexCounter = 0;
-        // Process each triangle
-        for (const triangle of trianglesInView) {
-            if (triangle.tessellationMeta.showThreshold * 0.075 > showThreshold) {
-                continue;
-            }
-            const result = (triangle.tessellationMeta.showThreshold < showThreshold) ? partialTessellation(triangle.tessellationMeta, bboxZooms, 5 // innerCuts parameter
-            ) : triangle.tessellationMeta.shortCut;
-            counter += result.vec3s.length;
-            indexCounter += result.indices.length;
-            if (_pickableState) {
-                // TODO: find a better way to fill indeces to final array
-                result.pickIndex = triangle.polygon.index;
-            }
-            if (_variativeColorsOnState) {
-                const color = triangle.polygon.color || [IndexAttributeEscapeValue, IndexAttributeEscapeValue, IndexAttributeEscapeValue, IndexAttributeEscapeValue];
-                result.variativeColors = color;
-                // Update offset for next triangle
-            }
-            results.push(result);
-        }
-        // Send results back
-        const output = {
-            vec3s: new Float32Array(counter),
-            longLats: new Float32Array(counter / 3 * 2),
-            indices: new Uint32Array(indexCounter),
-        };
-        if (_pickableState) {
-            output.pickIndices = new Float32Array(counter / 3);
-        }
-        if (_variativeColorsOnState) {
-            output.variativeColors = new Float32Array(counter / 3 * 4);
-        }
-        let currentVertexOffset = 0;
-        let indexOffset = 0;
-        for (const result of results) {
-            output.vec3s.set(result.vec3s, currentVertexOffset);
-            output.longLats.set(result.longLats, (currentVertexOffset / 3) * 2);
-            output.indices.set(result.indices.map(i => i + currentVertexOffset / 3), indexOffset);
-            currentVertexOffset += result.vec3s.length;
-            indexOffset += result.indices.length;
-            if (_pickableState) {
-                const subArray = output.pickIndices.subarray(currentVertexOffset / 3 - result.vec3s.length / 3, currentVertexOffset / 3);
-                subArray.fill(result.pickIndex);
-            }
-            if (_variativeColorsOnState && result.variativeColors) {
-                const vertexCount = result.vec3s.length / 3;
-                const colorStartIndex = (currentVertexOffset / 3 - vertexCount) * 4;
-                for (let i = 0; i < vertexCount; i++) {
-                    const offset = colorStartIndex + i * 4;
-                    output.variativeColors[offset] = result.variativeColors[0];
-                    output.variativeColors[offset + 1] = result.variativeColors[1];
-                    output.variativeColors[offset + 2] = result.variativeColors[2];
-                    output.variativeColors[offset + 3] = result.variativeColors[3];
-                }
-            }
-        }
-        const buffers = [
-            output.vec3s.buffer,
-            output.indices.buffer,
-            output.longLats.buffer,
-        ];
-        if (pickableState && output.pickIndices) {
-            buffers.push(output.pickIndices.buffer);
-        }
-        if (_variativeColorsOnState && output.variativeColors) {
-            buffers.push(output.variativeColors.buffer);
-        }
-        // eslint-disable-next-line no-restricted-globals
-        self.postMessage(output, buffers);
-    }
-    catch (error) {
-        console.error('Error in worker:', error);
-        // self.postMessage({ error: error.message || 'Unknown error in worker' });
-    }
-};