@pirireis/webglobeplugins 1.2.21 → 1.2.23

package/package.json

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

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

@@ -178,7 +178,6 @@ function sendToSubWorker(wrapper) {
         wrapper.lastBBOXData === null &&
         !_stateChanged)
         return false;
-    _stateChanged = false;
     wrapper.inProgress = true;
     wrapper.worker.postMessage({
         pickableState: _pickableState,
@@ -195,11 +194,16 @@ function triggerAllWorkers() {
     // If a batch is already running, do not start another one.
     if (_batchInFlight)
         return;
+    const shouldClearStateChanged = _stateChanged;
     let dispatched = 0;
     for (const w of _workers) {
         if (sendToSubWorker(w))
             dispatched++;
     }
+    // Only clear after we've attempted dispatching to all workers,
+    // so every worker can observe the new state.
+    if (shouldClearStateChanged)
+        _stateChanged = false;
     // Start barrier only if we actually dispatched work.
     if (dispatched > 0) {
         _batchInFlight = true;

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

@@ -15,6 +15,7 @@ export class TerrainPolygonSemiPlugin {
         pickable: false,
         pickablePause: false,
         variativeColorsOn: false,
+        useDepthTestOnExceedingTiltThresholdAngle: false,
         polygonStyle: {
             defaultColor: [0.5, 0.5, 1, 1],
             changeColorOnHover: true,
@@ -249,6 +250,13 @@ export class TerrainPolygonSemiPlugin {
         this._uboForRealEdgeArcs?.updateSingle("opacity", this._effectiveOpacity("edgeArc"));
         this.globe.DrawRender();
     }
+    setUseDepthTestOnExceedingTiltThresholdAngle(state) {
+        const oldState = this._options.useDepthTestOnExceedingTiltThresholdAngle;
+        if (oldState === state)
+            return;
+        this._options.useDepthTestOnExceedingTiltThresholdAngle = state;
+        this.globe.DrawRender();
+    }
     setChangeColorOnHoverState(state, target = "polygon") {
         const oldState = this._options[`${target}Style`].changeHoverColor;
         if (oldState === state)
@@ -270,30 +278,6 @@ export class TerrainPolygonSemiPlugin {
         this._uboHandler.updateSingle("private_isPickedOn", new Float32Array([state ? 0.0 : 1.0]));
         this.globe.DrawRender();
     }
-    setPickableState(state) {
-        throw new Error("setPickableState is buggy. use setPausePickableState instead.");
-        const oldState = this._options.pickable;
-        if (oldState === state)
-            return;
-        if (oldState === false && state === true) {
-            this._pickIndexBuffer = this.globe.gl.createBuffer();
-            this._uboHandler.updateSingle("private_isPickedOn", new Float32Array([1.0]));
-            this._uboHandler.updateSingle("hoverColor", new Float32Array(this._options.polygonStyle.hoverColor));
-            this._pickerDisplayer = new PickerDisplayer(this.globe, "R32I");
-        }
-        else if (oldState === true && state === false) {
-            this.globe.gl.deleteBuffer(this._pickIndexBuffer);
-            this._pickIndexBuffer = null;
-            this._uboHandler.updateSingle("private_isPickedOn", new Float32Array([0.0]));
-            this._uboHandler.updateSingle("private_pickedIndex", new Float32Array([-1]));
-            this._pickerDisplayer?.free();
-            this._pickerDisplayer = null;
-            this._lastPickedPolygon = null;
-        }
-        this._options.pickable = state;
-        this._workerContact.setPickableState(state);
-        this.globe.DrawRender();
-    }
     getPickedPolygon() {
         if (this._options.pickable === false) {
             throw new Error("TerrainPolygonSemiPlugin is not pickable. Set pickable option to true on construction to enable picking.");
@@ -399,6 +383,9 @@ export class TerrainPolygonSemiPlugin {
         }
     }
     _useDepth() {
+        if (!this._options.useDepthTestOnExceedingTiltThresholdAngle) {
+            return false;
+        }
         const { Tilt } = this.globe.api_GetCurrentLookInfo();
         const useDepth = Tilt > DEPTH_START_ANGLE;
         if (this._lastPickedPolygon !== null && useDepth) {
@@ -408,10 +395,14 @@ export class TerrainPolygonSemiPlugin {
         }
         return useDepth;
     }
-    getDepthStartAngle() {
+    getExceedingTiltThresholdAngle() {
         return DEPTH_START_ANGLE;
     }
     draw3D() {
+        if (!this.globe) {
+            console.warn("TerrainPolygonSemiPlugin.draw3D called before init");
+            return;
+        }
         const gl = this.globe.gl;
         const useDepth = this._useDepth();
         gl.enable(gl.BLEND);
@@ -496,6 +487,12 @@ export class TerrainPolygonSemiPlugin {
         }
         return targetUBO;
     }
+    sagUst4W(long, lat, rowSize, colSize, cellWidth = 100, cellHeight = 100, rotationAngle = 0) {
+        const globe = this.globe;
+        const data = calculateAndSetCoordinates(globe, "sol_ust", rowSize, colSize, 0, 0, 0, 0, cellWidth, cellHeight, [0.75, 0, 0, 1], rotationAngle, { long, lat });
+        //@ts-ignore
+        this.insertBulk(data);
+    }
 }
 function inputCheck(input) {
     if (!input.geometry || !Array.isArray(input.geometry) || input.geometry.length === 0) {
@@ -522,3 +519,111 @@ function roundTo6(n) {
     const rounded = Math.round(n * 1e6) / 1e6;
     return rounded;
 }
+function calculateAndSetCoordinates(globe, startType, // n13, sol_ust, sol_alt
+rowSize, // only sol_ust, sol_alt
+colSize, // only sol_ust, sol_alt
+topRowSize, // only n13
+bottomRowSize, // only n13
+leftColSize, // only n13
+rightColSize, // only n13
+cellWidth, cellHeight, cellColor = [0.75, 0, 0, 1], rotationAngle, // 0-360
+centerCoords) {
+    let totalRowSize, totalColSize, startRowOffset, startColOffset;
+    if (startType === 'n13') {
+        totalRowSize = topRowSize + bottomRowSize;
+        totalColSize = leftColSize + rightColSize;
+        startRowOffset = -topRowSize;
+        startColOffset = -leftColSize;
+    }
+    else if (startType === 'sol_ust') {
+        totalRowSize = rowSize;
+        totalColSize = colSize;
+        startRowOffset = 0;
+        startColOffset = 0;
+    }
+    else if (startType === 'sol_alt') {
+        totalRowSize = rowSize;
+        totalColSize = colSize;
+        startRowOffset = -rowSize;
+        startColOffset = 0;
+    }
+    else {
+        return;
+    }
+    const toRightAngle = 90 - rotationAngle;
+    const toBottomAngle = 180 - rotationAngle;
+    const toTopAngle = 0 - rotationAngle;
+    const toLeftAngle = 270 - rotationAngle;
+    // Traverses each cell (and 1 extra row) and:
+    // 3. Population of terrain polygon semi-plugin (tpsp) data
+    // Initialize flatArray
+    const coordsLength = (totalRowSize + 1) * (totalColSize + 1); // e.g. 3x5 grid has (3+1)*(5+1) = 24 coords (vertices)
+    const flatArray = Array(coordsLength);
+    // Calculate all vertex positions from center
+    for (let rowIndex = 0; rowIndex < totalRowSize + 1; rowIndex++) {
+        for (let colIndex = 0; colIndex < totalColSize + 1; colIndex++) {
+            const vertexIndex = rowIndex * (totalColSize + 1) + colIndex;
+            // Calculate offset from center in terms of cells
+            const rowOffsetFromCenter = startRowOffset + rowIndex;
+            const colOffsetFromCenter = startColOffset + colIndex;
+            // Calculate the actual position
+            // First move vertically from center
+            const verticalDistance = Math.abs(rowOffsetFromCenter) * cellHeight;
+            const verticalAngle = rowOffsetFromCenter < 0 ? toTopAngle : toBottomAngle;
+            let coords;
+            if (rowOffsetFromCenter === 0) {
+                coords = { ...centerCoords };
+            }
+            else {
+                coords = globe.Math.FindPointByPolar(centerCoords.long, centerCoords.lat, verticalDistance, verticalAngle);
+            }
+            // Then move horizontally
+            if (colOffsetFromCenter !== 0) {
+                const horizontalDistance = Math.abs(colOffsetFromCenter) * cellWidth;
+                const horizontalAngle = colOffsetFromCenter < 0 ? toLeftAngle : toRightAngle;
+                coords = globe.Math.FindPointByPolar(coords.long, coords.lat, horizontalDistance, horizontalAngle);
+            }
+            flatArray[vertexIndex] = { ...coords };
+        }
+    }
+    // Initialize tpspData array
+    const tpspData = [];
+    // Populate cells using the pre-calculated vertex positions
+    for (let rowIndex = 0; rowIndex < totalRowSize; rowIndex++) {
+        for (let colIndex = 0; colIndex < totalColSize; colIndex++) {
+            const cellIndex = rowIndex * totalColSize + colIndex;
+            // ******************************************** //
+            // * 1. Get coordinates from flatArray        * //
+            // ******************************************** //
+            const tlCoordsIndex = rowIndex * (totalColSize + 1) + colIndex;
+            const trCoordsIndex = tlCoordsIndex + 1;
+            const blCoordsIndex = (rowIndex + 1) * (totalColSize + 1) + colIndex;
+            const brCoordsIndex = blCoordsIndex + 1;
+            const tlCoords = flatArray[tlCoordsIndex];
+            const trCoords = flatArray[trCoordsIndex];
+            const blCoords = flatArray[blCoordsIndex];
+            const brCoords = flatArray[brCoordsIndex];
+            tpspData.push({
+                key: cellIndex + Date.now().toString(),
+                geometry: [
+                    {
+                        vertices: [
+                            tlCoords.long,
+                            tlCoords.lat,
+                            trCoords.long,
+                            trCoords.lat,
+                            brCoords.long,
+                            brCoords.lat,
+                            blCoords.long,
+                            blCoords.lat,
+                        ],
+                        holes: [],
+                    },
+                ],
+                color: cellColor,
+            });
+        }
+    }
+    // Bulk insert cell data to terrain polygon semi-plugin
+    return tpspData;
+}