@pirireis/webglobeplugins 1.0.2 → 1.0.4

package/{semiplugins/shape-on-terrain/terrain-polygon/data/worker-contact.ts → webglobeplugins/semiplugins/shape-on-terrain/terrain-polygon/data/worker-contact.js}

@@ -1,81 +1,64 @@
-import { PolygonInput, TerrainPolygonOptions } from "../types";
-import { WorkerInput, WorkerOutput, BBOXZOOMDATA } from "../types";
-import { Globe } from "../../../../types";
-import { MergedTilesInfo } from "../../../../Math/tessellation/tile-merger";
-import { DemTextureManager, DemTextureManagerCache } from "../../../../programs/totems/dem-textures-manager";
-import { RADIAN } from "../../../../Math/methods";
-
-export class WorkerContact {
-    private _masterWorker: Worker;
-    private _options: Pick<TerrainPolygonOptions, "pickable" | "variativeColorsOn">;
-    private onResult: (result: WorkerOutput) => void;
-    private demTextureManager: DemTextureManager = null as any;
-
-    constructor(globe: Globe, options: Pick<TerrainPolygonOptions, "pickable" | "variativeColorsOn">, onResult: (result: WorkerOutput) => void) {
-        this._options = options;
-        this.onResult = onResult;
-
-        // Initialize the Master Worker
-        // @ts-ignore
-        this._masterWorker = new Worker(new URL("./master-worker.js", import.meta.url), { type: 'module' });
-
-        this._masterWorker.onmessage = (event: MessageEvent<WorkerOutput>) => {
-            this.onResult(event.data);
-        }
-
-        // Initialize Master Worker state
-        this._masterWorker.postMessage({
-            pickableState: this._options.pickable,
-            variativeColorsOn: this._options.variativeColorsOn,
-            insertDeleteQueue: [],
-            bboxes: null,
-        } as WorkerInput);
-
-        this.demTextureManager = DemTextureManagerCache.get(globe);
-        this.demTextureManager.register(this);
-    }
-
-    setMergedTiles(mergedTilesInfo: MergedTilesInfo[]) {
-        const bboxesData: BBOXZOOMDATA = new Array(mergedTilesInfo.length);
-        for (let i = 0; i < mergedTilesInfo.length; i++) {
-            const { bbox, zoom } = mergedTilesInfo[i];
-            bboxesData[i] = {
-                zoom: zoom,
-                minX: bbox.ll.x * RADIAN,
-                minY: bbox.ll.y * RADIAN,
-                maxX: bbox.ur.x * RADIAN,
-                maxY: bbox.ur.y * RADIAN,
-            };
-        }
-
-        // Send BBOX updates to Master Worker
-        this._masterWorker.postMessage({
-            bboxes: bboxesData
-        } as Partial<WorkerInput>);
-    }
-
-    free() {
-        this.demTextureManager.unregister(this);
-        this._masterWorker.terminate();
-    }
-
-    insertBulk(polygons: PolygonInput[]) {
-        this._masterWorker.postMessage({
-            insertDeleteQueue: polygons
-        } as Partial<WorkerInput>);
-    }
-
-    deleteBulk(keys: string[]) {
-        this._masterWorker.postMessage({
-            insertDeleteQueue: keys
-        } as Partial<WorkerInput>);
-    }
-
-    clear() {
-        this._masterWorker.postMessage({
-            insertDeleteQueue: ["__CLEAR_ALL_ITEMS__"]
-        } as Partial<WorkerInput>);
-    }
-}
-
-
+import { DemTextureManagerCache } from "../../../../programs/totems/attachments/dem-textures-manager";
+import { RADIAN } from "../../../../Math/methods";
+export class WorkerContact {
+    _masterWorker;
+    _options;
+    onResult;
+    demTextureManager = null;
+    constructor(globe, options, onResult) {
+        this._options = options;
+        this.onResult = onResult;
+        // Initialize the Master Worker
+        // @ts-ignore
+        this._masterWorker = new Worker(new URL("./master-worker.ts", import.meta.url), { type: 'module' });
+        this._masterWorker.onmessage = (event) => {
+            this.onResult(event.data);
+        };
+        // Initialize Master Worker state
+        this._masterWorker.postMessage({
+            arcState: this._options.drawEdges,
+            pickableState: this._options.pickable,
+            variativeColorsOn: this._options.variativeColorsOn,
+            insertDeleteQueue: [],
+            bboxes: null,
+        });
+        this.demTextureManager = DemTextureManagerCache.get(globe);
+        this.demTextureManager.register(this);
+    }
+    setMergedTiles(mergedTilesInfo) {
+        const bboxesData = new Array(mergedTilesInfo.length);
+        for (let i = 0; i < mergedTilesInfo.length; i++) {
+            const { bbox, zoom } = mergedTilesInfo[i];
+            bboxesData[i] = {
+                zoom: zoom,
+                minX: bbox.ll.x * RADIAN,
+                minY: bbox.ll.y * RADIAN,
+                maxX: bbox.ur.x * RADIAN,
+                maxY: bbox.ur.y * RADIAN,
+            };
+        }
+        // Send BBOX updates to Master Worker
+        this._masterWorker.postMessage({
+            bboxes: bboxesData
+        });
+    }
+    free() {
+        this.demTextureManager.unregister(this);
+        this._masterWorker.terminate();
+    }
+    insertBulk(polygons) {
+        this._masterWorker.postMessage({
+            insertDeleteQueue: polygons
+        });
+    }
+    deleteBulk(keys) {
+        this._masterWorker.postMessage({
+            insertDeleteQueue: keys
+        });
+    }
+    clear() {
+        this._masterWorker.postMessage({
+            insertDeleteQueue: ["__CLEAR_ALL_ITEMS__"]
+        });
+    }
+}

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

@@ -0,0 +1,162 @@
+/// <reference lib="webworker" />
+/* eslint-disable no-restricted-globals */
+import { Cache } from "./cache";
+import { partialTessellation, uint32Escape, zoomLevelShowThreshold } from "../../../../Math/tessellation/triangle-tessellation";
+const cache = new Cache();
+let _pickableState = false;
+let _arcState = false;
+let _variativeColorsOnState = false;
+let showThreshold = 0;
+const NO_COLOR_ALPHA = 255;
+const MAX_ALPHA_VALUE = 254;
+function clamp01(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(1, value));
+}
+function colorToBytes(color) {
+    if (!color)
+        return [0, 0, 0, NO_COLOR_ALPHA];
+    const r = Math.round(clamp01(color[0]) * 255);
+    const g = Math.round(clamp01(color[1]) * 255);
+    const b = Math.round(clamp01(color[2]) * 255);
+    // Reserve 255 for "no color" sentinel.
+    const a = Math.round(clamp01(color[3]) * MAX_ALPHA_VALUE);
+    return [r, g, b, a];
+}
+self.onmessage = (event) => {
+    try {
+        const { bboxes, insertDeleteQueue, pickableState, variativeColorsOn, arcState } = event.data;
+        if (variativeColorsOn !== undefined) {
+            _variativeColorsOnState = variativeColorsOn;
+        }
+        if (pickableState !== undefined) {
+            _pickableState = pickableState;
+        }
+        if (arcState !== undefined) {
+            _arcState = arcState;
+        }
+        // Process insert/delete queue
+        if (insertDeleteQueue && insertDeleteQueue.length > 0) {
+            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);
+            if (bboxes.length > 0) {
+                showThreshold = zoomLevelShowThreshold(bboxes[0].zoom, 0.05);
+            }
+        }
+        const trianglesInView = cache.search();
+        const results = [];
+        // Convert bbox to BBoxZoom format for partialTessellation
+        // @ts-ignore
+        const bboxZooms = bboxes
+            ? bboxes.map((b) => ({
+                bbox: {
+                    min: [b.minX, b.minY],
+                    max: [b.maxX, b.maxY],
+                },
+                zoom: b.zoom,
+            }))
+            : [];
+        let counter = 0;
+        let indexCounter = 0;
+        let arcCounter = 0;
+        for (const triangle of trianglesInView) {
+            if (triangle.tessellationMeta.showThreshold * 0.075 > showThreshold) {
+                continue;
+            }
+            const tessResult = triangle.tessellationMeta.showThreshold < showThreshold
+                ? partialTessellation(triangle.tessellationMeta, bboxZooms, 5, _arcState)
+                : triangle.tessellationMeta.shortCut;
+            const result = {
+                vec3s: tessResult.vec3s,
+                indices: tessResult.indices,
+                longLats: tessResult.longLats,
+                realEdgeArcIndices: _arcState ? tessResult.realEdgeArcIndices : null,
+            };
+            counter += result.vec3s.length;
+            indexCounter += result.indices.length;
+            if (_pickableState) {
+                result.pickIndex = triangle.polygon.index;
+            }
+            if (_arcState) {
+                arcCounter += result.realEdgeArcIndices ? result.realEdgeArcIndices.length : 0;
+            }
+            if (_variativeColorsOnState) {
+                result.variativeColors = colorToBytes(triangle.polygon.color);
+            }
+            results.push(result);
+        }
+        const totalArcCount = arcCounter;
+        const output = {
+            vec3s: new Float32Array(counter),
+            longLats: new Float32Array((counter / 3) * 2),
+            indices: new Uint32Array(indexCounter),
+            realEdgeArcIndices: _arcState ? new Uint32Array(totalArcCount) : null,
+            pickIndices: _pickableState ? new Float32Array(counter / 3) : null,
+            variativeColors: _variativeColorsOnState ? new Uint8Array((counter / 3) * 4) : null,
+        };
+        let currentVertexOffset = 0;
+        let indexOffset = 0;
+        let arcOffset = 0;
+        for (const result of results) {
+            output.vec3s.set(result.vec3s, currentVertexOffset);
+            output.longLats.set(result.longLats, (currentVertexOffset / 3) * 2);
+            const startVertex = currentVertexOffset / 3;
+            for (let i = 0; i < result.indices.length; i++) {
+                output.indices[indexOffset + i] = result.indices[i] + startVertex;
+            }
+            const vertexCount = result.vec3s.length / 3;
+            currentVertexOffset += result.vec3s.length;
+            indexOffset += result.indices.length;
+            if (_pickableState && output.pickIndices && result.pickIndex !== undefined) {
+                output.pickIndices.fill(result.pickIndex, startVertex, startVertex + vertexCount);
+            }
+            if (_variativeColorsOnState && output.variativeColors && result.variativeColors) {
+                for (let i = 0; i < vertexCount; i++) {
+                    const o = (startVertex + i) * 4;
+                    output.variativeColors[o + 0] = result.variativeColors[0];
+                    output.variativeColors[o + 1] = result.variativeColors[1];
+                    output.variativeColors[o + 2] = result.variativeColors[2];
+                    output.variativeColors[o + 3] = result.variativeColors[3];
+                }
+            }
+            if (_arcState && output.realEdgeArcIndices && result.realEdgeArcIndices) {
+                for (let i = 0; i < result.realEdgeArcIndices.length; i++) {
+                    const value = result.realEdgeArcIndices[i];
+                    if (value === uint32Escape) {
+                        output.realEdgeArcIndices[arcOffset + i] = uint32Escape;
+                    }
+                    else {
+                        output.realEdgeArcIndices[arcOffset + i] = value + startVertex;
+                    }
+                }
+                arcOffset += result.realEdgeArcIndices.length;
+            }
+        }
+        const buffers = [output.vec3s.buffer, output.indices.buffer, output.longLats.buffer];
+        if (_arcState && output.realEdgeArcIndices)
+            buffers.push(output.realEdgeArcIndices.buffer);
+        if (_pickableState && output.pickIndices)
+            buffers.push(output.pickIndices.buffer);
+        if (_variativeColorsOnState && output.variativeColors)
+            buffers.push(output.variativeColors.buffer);
+        self.postMessage(output, buffers);
+    }
+    catch (error) {
+        console.error("Error in worker:", error);
+    }
+};