@pirireis/webglobeplugins 1.1.0 → 1.1.1

package/Math/tessellation/triangle-tessellation.js

@@ -44,8 +44,12 @@ function radianCheck(point) {
 }
 const _3RealEdges = new Uint32Array([uint32Escape, 0, 1, 2, 0]);
 const _2RealEdges_dismiss2 = new Uint32Array([uint32Escape, 0, 1, 2]);
-const _2RealEdges_dismiss1 = new Uint32Array([uint32Escape, 2, 0, 1]);
-const _2RealEdges_dismiss0 = new Uint32Array([uint32Escape, 1, 2, 0]);
+// For 2-real-edge cases, the strip must traverse only the two real edges.
+// Vertex indices are local: 0=p1, 1=p2, 2=p3.
+// - dismiss1: real edges are (1-2) and (2-0) => strip 1->2->0
+// - dismiss0: real edges are (2-0) and (0-1) => strip 2->0->1
+const _2RealEdges_dismiss1 = new Uint32Array([uint32Escape, 1, 2, 0]);
+const _2RealEdges_dismiss0 = new Uint32Array([uint32Escape, 2, 0, 1]);
 const _1realEdge_0 = new Uint32Array([uint32Escape, 0, 1]);
 const _1realEdge_1 = new Uint32Array([uint32Escape, 1, 2]);
 const _1realEdge_2 = new Uint32Array([uint32Escape, 2, 0]);

package/package.json

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

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

@@ -125,6 +125,11 @@ function mergeAndSendResults() {
     let vertexOffset = 3; // reserve 3 vertices
     let arcCounter = BASE_REAL_EDGE_ARC_INDICES;
     for (const out of validOutputs) {
+        const outPosVertexCount = Math.floor(out.vec3s.length / 3);
+        const outXYVertexCount = Math.floor(out.longLats.length / 2);
+        const outPickVertexCount = out.pickIndices ? out.pickIndices.length : Number.POSITIVE_INFINITY;
+        const outColorVertexCount = out.variativeColors ? Math.floor(out.variativeColors.length / 4) : Number.POSITIVE_INFINITY;
+        const outSafeVertexCount = Math.min(outPosVertexCount, outXYVertexCount, outPickVertexCount, outColorVertexCount);
         merged.vec3s.set(out.vec3s, offsetVec3s);
         offsetVec3s += out.vec3s.length;
         for (let i = 0; i < out.indices.length; i++) {
@@ -133,8 +138,15 @@ function mergeAndSendResults() {
         if (_arcState && merged.realEdgeArcIndices && out.realEdgeArcIndices) {
             for (let i = 0; i < out.realEdgeArcIndices.length; i++) {
                 const realEdgeIndice = out.realEdgeArcIndices[i];
-                merged.realEdgeArcIndices[arcCounter++] =
-                    realEdgeIndice === uint32Escape ? uint32Escape : realEdgeIndice + vertexOffset;
+                if (realEdgeIndice === uint32Escape) {
+                    merged.realEdgeArcIndices[arcCounter++] = uint32Escape;
+                }
+                else {
+                    // Defensive: discard any out-of-range arc indices so we never
+                    // generate a merged index that references missing attribute data.
+                    merged.realEdgeArcIndices[arcCounter++] =
+                        realEdgeIndice >= outSafeVertexCount ? uint32Escape : realEdgeIndice + vertexOffset;
+                }
             }
         }
         offsetIndices += out.indices.length;

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

@@ -141,7 +141,10 @@ self.onmessage = (event) => {
                         output.realEdgeArcIndices[arcOffset + i] = uint32Escape;
                     }
                     else {
-                        output.realEdgeArcIndices[arcOffset + i] = value + startVertex;
+                        // Guard against occasional out-of-range arc indices.
+                        // Invalid indices would crash ANGLE with "vertex buffer not big enough".
+                        output.realEdgeArcIndices[arcOffset + i] =
+                            value >= vertexCount ? uint32Escape : value + startVertex;
                     }
                 }
                 arcOffset += result.realEdgeArcIndices.length;

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

@@ -115,11 +115,18 @@ export class TerrainPolygonSemiPlugin {
         this._drawPointsRangeIndexParams.elementBuffer = this._elementArrayBuffer;
     }
     insertBulk(polygons) {
-        // if (this._indexPolygonMap) {
         let filteredPolygons = polygons.filter(inputCheck);
+        // Drop precision to 8 digits after dot before moving forward
+        filteredPolygons = filteredPolygons.map((p) => ({
+            ...p,
+            geometry: p.geometry.map((g) => ({
+                ...g,
+                vertices: g.vertices.map((v) => roundTo8(v)),
+            })),
+        }));
         filteredPolygons = this._indexPolygonMap.insertBulk(filteredPolygons);
-        // }
         this._workerContact.insertBulk(filteredPolygons);
+        this.globe.DrawRender(); // If the window is not focused, this may be needed to force processing.
     }
     deleteBulk(keys) {
         this._workerContact.deleteBulk(keys);
@@ -149,6 +156,37 @@ export class TerrainPolygonSemiPlugin {
     }
     setBuffers(data) {
         const gl = this.globe.gl;
+        const posVertexCount = Math.floor(data.vec3s.length / 3);
+        const xyVertexCount = Math.floor(data.longLats.length / 2);
+        let safeVertexCount = Math.min(posVertexCount, xyVertexCount);
+        if (this._options.pickable && data.pickIndices) {
+            safeVertexCount = Math.min(safeVertexCount, data.pickIndices.length);
+        }
+        if (this._options.variativeColorsOn && data.variativeColors) {
+            safeVertexCount = Math.min(safeVertexCount, Math.floor(data.variativeColors.length / 4));
+        }
+        // Guard against invalid indices referencing beyond uploaded attribute buffers.
+        // This prevents ANGLE "Vertex buffer is not big enough for the draw call" errors.
+        let maxTriangleIndex = -1;
+        for (let i = 0; i < data.indices.length; i++) {
+            const v = data.indices[i];
+            if (v > maxTriangleIndex)
+                maxTriangleIndex = v;
+        }
+        const trianglesInvalid = safeVertexCount === 0 || maxTriangleIndex >= safeVertexCount;
+        if (trianglesInvalid) {
+            console.warn("TerrainPolygonSemiPlugin: skipping draw due to invalid vertex/index sizing", {
+                posVertexCount,
+                xyVertexCount,
+                safeVertexCount,
+                indicesLength: data.indices.length,
+                maxTriangleIndex,
+                pickIndicesLength: data.pickIndices?.length ?? null,
+                variativeColorsLength: data.variativeColors?.length ?? null,
+            });
+            this._drawRangeIndexParams.drawRange.count = 0;
+            this._drawPointsRangeIndexParams.drawRange.count = 0;
+        }
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._elementArrayBuffer);
         gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data.indices, gl.STREAM_DRAW);
         gl.bindBuffer(gl.ARRAY_BUFFER, this._vec3Buffer);
@@ -166,7 +204,25 @@ export class TerrainPolygonSemiPlugin {
         if (this._options.drawEdges && data.realEdgeArcIndices) {
             gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._drawRealEdgeArcs.elementBuffer);
             gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data.realEdgeArcIndices, gl.STREAM_DRAW);
-            this._drawRealEdgeArcs.drawRange.count = data.realEdgeArcIndices.length;
+            // If the edge index stream includes primitive-restart (0xFFFFFFFF) indices,
+            // the draw call requires PRIMITIVE_RESTART_FIXED_INDEX to be enabled.
+            // Also validate edge indices are within bounds.
+            let maxEdgeIndex = -1;
+            const PRIMITIVE_RESTART_INDEX = 0xFFFFFFFF;
+            for (let i = 0; i < data.realEdgeArcIndices.length; i++) {
+                const v = data.realEdgeArcIndices[i];
+                if (v === PRIMITIVE_RESTART_INDEX)
+                    continue;
+                if (v > maxEdgeIndex)
+                    maxEdgeIndex = v;
+            }
+            if (safeVertexCount === 0 || maxEdgeIndex >= safeVertexCount) {
+                console.warn("TerrainPolygonSemiPlugin: disabling edge draw due to invalid edge indices", { safeVertexCount, maxEdgeIndex, edgeIndexCount: data.realEdgeArcIndices.length });
+                this._drawRealEdgeArcs.drawRange.count = 0;
+            }
+            else {
+                this._drawRealEdgeArcs.drawRange.count = data.realEdgeArcIndices.length;
+            }
         }
         else {
             this._drawRealEdgeArcs.drawRange.count = 0;
@@ -230,9 +286,6 @@ export class TerrainPolygonSemiPlugin {
             this._pickerDisplayer.clearTextures();
             // gl.enable(gl.DEPTH_TEST);
         }
-        else {
-            // gl.disable(gl.DEPTH_TEST);
-        }
         gl.frontFace(gl.CW);
         this._program.draw(this._vao, this._drawRangeIndexParams, this._uboHandler);
         gl.frontFace(gl.CCW);
@@ -303,3 +356,6 @@ function getGlStates(gl) {
         texture2DArray: gl.getParameter(gl.TEXTURE_BINDING_2D_ARRAY),
     };
 }
+function roundTo8(n) {
+    return Math.round(n * 1e8) / 1e8;
+}