@pirireis/webglobeplugins 1.0.2 → 1.0.3

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

@@ -1,196 +1,177 @@
-/// <reference lib="webworker" />
-
-const _workers = [];
-const _workerMap = new Map();
-let _maxWorkers = 4; // Default, updated in init
-let _nextWorkerIndex = 0;
-
-// Configuration state to pass to new workers or re-broadcast
-let _pickableState;
-let _variativeColorsOn;
-
-// Initialize workers
-function initWorkers() {
-    _maxWorkers = Math.max(1, (navigator.hardwareConcurrency / 2 || 3) - 1);
-    for (let i = 0; i < _maxWorkers; i++) {
-        addWorker();
-    }
-}
-
-function addWorker() {
-    const worker = new Worker(new URL("./worker.js", import.meta.url), { type: 'module' });
-
-    const wrapper = {
-        worker,
-        inProgress: false,
-        insertDeleteQueue: [],
-        lastBBOXData: null,
-        itemCount: 0,
-        lastOutput: null
-    };
-
-    worker.onmessage = (event) => {
-        wrapper.inProgress = false;
-        wrapper.lastOutput = event.data;
-        mergeAndSendResults();
-        sendToSubWorker(wrapper);
-    };
-
-    // Initialize sub-worker with current global state
-    worker.postMessage({
-        pickableState: _pickableState,
-        variativeColorsOn: _variativeColorsOn,
-        insertDeleteQueue: [],
-        bboxes: null,
-    });
-
-    _workers.push(wrapper);
-}
-
-function mergeAndSendResults() {
-    let totalVec3s = 0;
-    let totalIndices = 0;
-    let totalLongLats = 0;
-    let totalPickIndices = 0;
-    let totalVariativeColors = 0;
-
-    const validOutputs = [];
-
-    for (const w of _workers) {
-        if (w.lastOutput) {
-            validOutputs.push(w.lastOutput);
-            totalVec3s += w.lastOutput.vec3s.length;
-            totalIndices += w.lastOutput.indices.length;
-            totalLongLats += w.lastOutput.longLats.length;
-            if (w.lastOutput.pickIndices) totalPickIndices += w.lastOutput.pickIndices.length;
-            if (w.lastOutput.variativeColors) totalVariativeColors += w.lastOutput.variativeColors.length;
-        }
-    }
-
-    if (validOutputs.length === 0) return;
-
-    const merged = {
-        vec3s: new Float32Array(totalVec3s),
-        indices: new Uint32Array(totalIndices),
-        longLats: new Float32Array(totalLongLats),
-        pickIndices: totalPickIndices > 0 ? new Float32Array(totalPickIndices) : null,
-        variativeColors: totalVariativeColors > 0 ? new Float32Array(totalVariativeColors) : null
-    };
-
-    let offsetVec3s = 0;
-    let offsetIndices = 0;
-    let offsetLongLats = 0;
-    let offsetPickIndices = 0;
-    let offsetVariativeColors = 0;
-    let vertexOffset = 0;
-
-    for (const out of validOutputs) {
-        merged.vec3s.set(out.vec3s, offsetVec3s);
-        offsetVec3s += out.vec3s.length;
-
-        for (let i = 0; i < out.indices.length; i++) {
-            merged.indices[offsetIndices + i] = out.indices[i] + vertexOffset;
-        }
-        offsetIndices += out.indices.length;
-        vertexOffset += out.vec3s.length / 3;
-
-        merged.longLats.set(out.longLats, offsetLongLats);
-        offsetLongLats += out.longLats.length;
-
-        if (merged.pickIndices && out.pickIndices) {
-            merged.pickIndices.set(out.pickIndices, offsetPickIndices);
-            offsetPickIndices += out.pickIndices.length;
-        }
-
-        if (merged.variativeColors && out.variativeColors) {
-            merged.variativeColors.set(out.variativeColors, offsetVariativeColors);
-            offsetVariativeColors += out.variativeColors.length;
-        }
-    }
-
-    // Send merged result to Main Thread
-    // eslint-disable-next-line no-restricted-globals
-    self.postMessage(merged, [
-        merged.vec3s.buffer,
-        merged.indices.buffer,
-        merged.longLats.buffer,
-        ...(merged.pickIndices ? [merged.pickIndices.buffer] : []),
-        ...(merged.variativeColors ? [merged.variativeColors.buffer] : [])
-    ]);
-}
-
-function sendToSubWorker(wrapper) {
-    if (wrapper.inProgress) return;
-    if (wrapper.insertDeleteQueue.length === 0 && wrapper.lastBBOXData === null) return;
-
-    wrapper.inProgress = true;
-    wrapper.worker.postMessage({
-        pickableState: undefined, // State is set on init, only send updates if needed
-        variativeColorsOn: undefined,
-        bboxes: wrapper.lastBBOXData,
-        insertDeleteQueue: wrapper.insertDeleteQueue,
-    });
-
-    wrapper.lastBBOXData = null;
-    wrapper.insertDeleteQueue = [];
-}
-
-function triggerAllWorkers() {
-    for (const w of _workers) {
-        sendToSubWorker(w);
-    }
-}
-
-// Handle messages from Main Thread
-// eslint-disable-next-line no-restricted-globals
-self.onmessage = (event) => {
-    const { bboxes, insertDeleteQueue, pickableState, variativeColorsOn } = event.data;
-
-    // Initialize if not already done
-    if (_workers.length === 0) {
-        _pickableState = pickableState;
-        _variativeColorsOn = variativeColorsOn;
-        initWorkers();
-    }
-
-    // Handle BBOX updates
-    if (bboxes) {
-        for (const w of _workers) {
-            w.lastBBOXData = bboxes;
-        }
-    }
-
-    // Handle Insert/Delete
-    if (insertDeleteQueue && insertDeleteQueue.length > 0) {
-        if (insertDeleteQueue[0] === "__CLEAR_ALL_ITEMS__") {
-            _workerMap.clear();
-            for (const w of _workers) {
-                w.insertDeleteQueue = ["__CLEAR_ALL_ITEMS__"];
-                w.itemCount = 0;
-                w.lastOutput = null;
-            }
-        } else {
-            for (const item of insertDeleteQueue) {
-                if (typeof item === 'string') {
-                    // Delete
-                    const workerIdx = _workerMap.get(item);
-                    if (workerIdx !== undefined) {
-                        _workers[workerIdx].insertDeleteQueue.push(item);
-                        _workers[workerIdx].itemCount--;
-                        _workerMap.delete(item);
-                    }
-                } else {
-                    // Insert
-                    let workerIdx = _workerMap.get(item.key);
-                    if (workerIdx === undefined) {
-                        workerIdx = _nextWorkerIndex;
-                        _workerMap.set(item.key, workerIdx);
-                        _workers[workerIdx].itemCount++;
-                        _nextWorkerIndex = (_nextWorkerIndex + 1) % _workers.length;
-                    }
-                    _workers[workerIdx].insertDeleteQueue.push(item);
-                }
-            }
-        }
-    } triggerAllWorkers();
-};
+/// <reference lib="webworker" />
+const _workers = [];
+const _workerMap = new Map();
+let _maxWorkers = 4; // Default, updated in init
+let _nextWorkerIndex = 0;
+// Configuration state to pass to new workers or re-broadcast
+let _pickableState;
+let _variativeColorsOn;
+// Initialize workers
+function initWorkers() {
+    _maxWorkers = Math.max(1, (navigator.hardwareConcurrency || 4) - 1);
+    for (let i = 0; i < _maxWorkers; i++) {
+        addWorker();
+    }
+}
+function addWorker() {
+    // @ts-ignore
+    const worker = new Worker(new URL("./worker.js", import.meta.url), { type: 'module' });
+    const wrapper = {
+        worker,
+        inProgress: false,
+        insertDeleteQueue: [],
+        lastBBOXData: null,
+        itemCount: 0,
+        lastOutput: null
+    };
+    worker.onmessage = (event) => {
+        wrapper.inProgress = false;
+        wrapper.lastOutput = event.data;
+        mergeAndSendResults();
+        sendToSubWorker(wrapper);
+    };
+    // Initialize sub-worker with current global state
+    worker.postMessage({
+        pickableState: _pickableState,
+        variativeColorsOn: _variativeColorsOn,
+        insertDeleteQueue: [],
+        bboxes: null,
+    });
+    _workers.push(wrapper);
+}
+function mergeAndSendResults() {
+    let totalVec3s = 0;
+    let totalIndices = 0;
+    let totalLongLats = 0;
+    let totalPickIndices = 0;
+    let totalVariativeColors = 0;
+    const validOutputs = [];
+    for (const w of _workers) {
+        if (w.lastOutput) {
+            validOutputs.push(w.lastOutput);
+            totalVec3s += w.lastOutput.vec3s.length;
+            totalIndices += w.lastOutput.indices.length;
+            totalLongLats += w.lastOutput.longLats.length;
+            if (w.lastOutput.pickIndices)
+                totalPickIndices += w.lastOutput.pickIndices.length;
+            if (w.lastOutput.variativeColors)
+                totalVariativeColors += w.lastOutput.variativeColors.length;
+        }
+    }
+    if (validOutputs.length === 0)
+        return;
+    const merged = {
+        vec3s: new Float32Array(totalVec3s),
+        indices: new Uint32Array(totalIndices),
+        longLats: new Float32Array(totalLongLats),
+        pickIndices: totalPickIndices > 0 ? new Float32Array(totalPickIndices) : null,
+        variativeColors: totalVariativeColors > 0 ? new Float32Array(totalVariativeColors) : null
+    };
+    let offsetVec3s = 0;
+    let offsetIndices = 0;
+    let offsetLongLats = 0;
+    let offsetPickIndices = 0;
+    let offsetVariativeColors = 0;
+    let vertexOffset = 0;
+    for (const out of validOutputs) {
+        merged.vec3s.set(out.vec3s, offsetVec3s);
+        offsetVec3s += out.vec3s.length;
+        for (let i = 0; i < out.indices.length; i++) {
+            merged.indices[offsetIndices + i] = out.indices[i] + vertexOffset;
+        }
+        offsetIndices += out.indices.length;
+        vertexOffset += out.vec3s.length / 3;
+        merged.longLats.set(out.longLats, offsetLongLats);
+        offsetLongLats += out.longLats.length;
+        if (merged.pickIndices && out.pickIndices) {
+            merged.pickIndices.set(out.pickIndices, offsetPickIndices);
+            offsetPickIndices += out.pickIndices.length;
+        }
+        if (merged.variativeColors && out.variativeColors) {
+            merged.variativeColors.set(out.variativeColors, offsetVariativeColors);
+            offsetVariativeColors += out.variativeColors.length;
+        }
+    }
+    // Send merged result to Main Thread
+    self.postMessage(merged, [
+        merged.vec3s.buffer,
+        merged.indices.buffer,
+        merged.longLats.buffer,
+        ...(merged.pickIndices ? [merged.pickIndices.buffer] : []),
+        ...(merged.variativeColors ? [merged.variativeColors.buffer] : [])
+    ]);
+}
+function sendToSubWorker(wrapper) {
+    if (wrapper.inProgress)
+        return;
+    if (wrapper.insertDeleteQueue.length === 0 && wrapper.lastBBOXData === null)
+        return;
+    wrapper.inProgress = true;
+    wrapper.worker.postMessage({
+        pickableState: undefined, // State is set on init, only send updates if needed
+        variativeColorsOn: undefined,
+        bboxes: wrapper.lastBBOXData,
+        insertDeleteQueue: wrapper.insertDeleteQueue,
+    });
+    wrapper.lastBBOXData = null;
+    wrapper.insertDeleteQueue = [];
+}
+function triggerAllWorkers() {
+    for (const w of _workers) {
+        sendToSubWorker(w);
+    }
+}
+// Handle messages from Main Thread
+self.onmessage = (event) => {
+    const { bboxes, insertDeleteQueue, pickableState, variativeColorsOn } = event.data;
+    // Initialize if not already done
+    if (_workers.length === 0) {
+        _pickableState = pickableState;
+        _variativeColorsOn = variativeColorsOn;
+        initWorkers();
+    }
+    // Handle BBOX updates
+    if (bboxes) {
+        for (const w of _workers) {
+            w.lastBBOXData = bboxes;
+        }
+    }
+    // Handle Insert/Delete
+    if (insertDeleteQueue && insertDeleteQueue.length > 0) {
+        if (insertDeleteQueue[0] === "__CLEAR_ALL_ITEMS__") {
+            _workerMap.clear();
+            for (const w of _workers) {
+                w.insertDeleteQueue = ["__CLEAR_ALL_ITEMS__"];
+                w.itemCount = 0;
+                w.lastOutput = null;
+            }
+        }
+        else {
+            for (const item of insertDeleteQueue) {
+                if (typeof item === 'string') {
+                    // Delete
+                    const workerIdx = _workerMap.get(item);
+                    if (workerIdx !== undefined) {
+                        _workers[workerIdx].insertDeleteQueue.push(item);
+                        _workers[workerIdx].itemCount--;
+                        _workerMap.delete(item);
+                    }
+                }
+                else {
+                    // Insert
+                    let workerIdx = _workerMap.get(item.key);
+                    if (workerIdx === undefined) {
+                        workerIdx = _nextWorkerIndex;
+                        _workerMap.set(item.key, workerIdx);
+                        _workers[workerIdx].itemCount++;
+                        _nextWorkerIndex = (_nextWorkerIndex + 1) % _workers.length;
+                    }
+                    _workers[workerIdx].insertDeleteQueue.push(item.key);
+                }
+            }
+        }
+    }
+    // Trigger all workers to process the new data
+    triggerAllWorkers();
+};
+export {};

package/semiplugins/shape-on-terrain/terrain-polygon/data/{polygon-to-triangles.ts → polygon-to-triangles.js}

@@ -1,144 +1,100 @@
-/**
- * # 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 { Radian } from "../../../../types";
-
-import { PolygonPluginInput, TrianglesMiddleData } from "../types";
-import { haversine } from "../../../../Math/haversine";
-
-
-import earcut from "earcut";
-
-
-/**
- * 
- */
-
-function __pointsInBetweenGreateCircle(
-    lat1: Radian,
-    lon1: Radian,
-    lat2: Radian,
-    lon2: Radian,
-    unitSphereDistance: number
-): number[] | null {
-    const points: number[] = [];
-
-    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: PolygonPluginInput,
-    kmThreshold: number
-): PolygonPluginInput {
-    const unitSphereDistance = kmThreshold / 6371; // Earth radius in km
-
-    const newGeometries = polygon.geometry.map(geom => {
-        const { vertices, holes } = geom;
-        const newVertices: number[] = [];
-        const newHoles: number[] = [];
-
-        const processRing = (start: number, end: number) => {
-            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: PolygonPluginInput, kmThreshold: number): TrianglesMiddleData {
-
-    const finalVertices: number[] = [];
-    const finalIndices: number[] = [];
-    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 };
+/**
+ * # 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 };