@pirireis/webglobeplugins 1.2.21 → 1.2.22

package/package.json

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

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

@@ -270,30 +270,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.");
@@ -496,6 +472,34 @@ export class TerrainPolygonSemiPlugin {
         }
         return targetUBO;
     }
+    // setPickableState(state: boolean): void {
+    //     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();
+    // }
+    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 +526,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;
+}