@pirireis/webglobeplugins 1.1.18 → 1.1.20

package/Math/tessellation/triangle-tessellation.js

@@ -288,17 +288,17 @@ export function partialTessellation(triangleMeta, limits, innerCuts, calculateRe
      */
     const _f32 = /*@__PURE__*/ new Float32Array(1);
     const _u32 = /*@__PURE__*/ new Uint32Array(_f32.buffer);
-    const float32Bits = (n) => {
-        _f32[0] = n;
-        return _u32[0];
-    };
+    // const float32Bits = (n: number): number => {
+    //     _f32[0] = n;
+    //     return _u32[0];
+    // };
     const addPoint = (longLat, vec3, edgeIndex) => {
         const xy = radianToMercatorXY(longLat);
         const x = Math.fround(xy[0]);
         const y = Math.fround(xy[1]);
         // Use float32 bit patterns for an exact, stable key.
-        // const key = `${xy[0].toFixed(12)},${xy[1].toFixed(12)}`;
-        const key = `${float32Bits(x)},${float32Bits(y)}`;
+        const key = `${xy[0].toFixed(8)},${xy[1].toFixed(8)}`;
+        // const key = `${float32Bits(x)},${float32Bits(y)}`;
         let index = pointMap.get(key);
         if (index !== undefined) {
             if (edgeIndex !== undefined) {

package/package.json

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

package/programs/polygon-on-globe/texture-dem-triangles.js

@@ -18,12 +18,13 @@ const uniformBindingPoints = {
 export const IndexAttributeEscapeValue = -1;
 const styleBlockManager = new UniformBlockManager('Style', [
     { name: "defaultColor", type: "vec4", value: new Float32Array([0.0, 0.0, 0.0, 0.0]) },
-    { name: "pickedColor", type: "vec4", value: new Float32Array([0, 0, 0, 0]) },
+    { name: "hoverColor", type: "vec4", value: new Float32Array([0, 0, 0, 0]) },
     { name: "u_pointSize", type: "float", value: new Float32Array([6.0]) },
     { name: "opacity", type: "float", value: new Float32Array([1.0]) },
-    { name: "private_isPickedOn", type: "bool", value: new Float32Array([0]) },
     { name: "private_pickedIndex", type: "uint", value: new Uint32Array([0]) },
+    { name: "private_isPickedOn", type: "bool", value: new Float32Array([0]) },
     { name: "useDefaultColor", type: "bool", value: new Float32Array([0]) },
+    { name: "private_changeHoverColor", type: "bool", value: new Float32Array([1]) },
 ], uniformBindingPoints.style);
 const vertexShaderSource = `#version 300 es
 #pragma vscode_glsllint_stage : vert
@@ -91,8 +92,8 @@ void main() {
     }
 
     if (private_isPickedOn ==  true){
-        if (a_index == private_pickedIndex) {
-            v_color = pickedColor;
+        if (a_index == private_pickedIndex && private_changeHoverColor == true ) {
+            v_color = hoverColor;
         }
         v_index = a_index;
     }

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

@@ -15,13 +15,15 @@ export class TerrainPolygonSemiPlugin {
         variativeColorsOn: false,
         polygonStyle: {
             defaultColor: [0.5, 0.5, 1, 1],
-            pickedColor: [1, 0, 0, 1],
+            changeColorOnHover: true,
+            hoverColor: [1, 0, 0, 1],
             opacity: 1.0,
             useDefaultColor: false,
         },
         edgeStyle: {
             defaultColor: [1, 1, 0, 1],
-            pickedColor: [1, 0, 0, 1],
+            hoverColor: [1, 0, 0, 1],
+            changeColorOnHover: true,
             opacity: 1.0,
             useDefaultColor: true,
         },
@@ -112,7 +114,8 @@ export class TerrainPolygonSemiPlugin {
             this._pickIndexBuffer = gl.createBuffer();
             this._pickerDisplayer = new PickerDisplayer(this.globe, "R16UI");
             this._uboHandler.updateSingle("private_isPickedOn", new Float32Array([1.0]));
-            this._uboHandler.updateSingle("pickedColor", new Float32Array(this._options.polygonStyle.pickedColor));
+            this._uboHandler.updateSingle("hoverColor", new Float32Array(this._options.polygonStyle.hoverColor));
+            this._uboHandler.updateSingle("private_changeHoverColor", new Float32Array([this._options.polygonStyle.changeColorOnHover ? 1 : 0]));
         }
         else {
             this._uboHandler.updateSingle("private_isPickedOn", new Float32Array([0.0]));
@@ -123,6 +126,7 @@ export class TerrainPolygonSemiPlugin {
             this._uboForRealEdgeArcs.updateSingle("useDefaultColor", new Float32Array([1]));
             this._uboForRealEdgeArcs.updateSingle("opacity", this._effectiveOpacity("edgeArc"));
             this._uboForRealEdgeArcs.updateSingle("private_isPickedOn", new Float32Array([0.0]));
+            this._uboForRealEdgeArcs.updateSingle("private_changeHoverColor", new Float32Array([this._options.edgeStyle.changeColorOnHover ? 1 : 0]));
             this._drawRealEdgeArcs.elementBuffer = gl.createBuffer();
         }
         if (this._options.variativeColorsOn) {
@@ -175,32 +179,22 @@ export class TerrainPolygonSemiPlugin {
         if (name.startsWith("private_")) {
             throw new Error(`Cannot set private uniform ${name}`);
         }
-        const isStyleKey = name === "defaultColor" || name === "pickedColor" || name === "opacity" || name === "useDefaultColor";
-        let targetUBO;
-        if (target === "polygon") {
-            targetUBO = this._uboHandler;
-        }
-        else if (target === "edgeArc") {
-            targetUBO = this._uboForRealEdgeArcs;
-        }
-        else {
-            console.warn(`Unknown target ${target} for setUniform, must be "polygon" or "edgeArc"`);
-            return;
-        }
+        const isStyleKey = name === "defaultColor" || name === "hoverColor" || name === "opacity" || name === "useDefaultColor";
+        const ubo = this.__getUBO(target);
         if (isStyleKey) {
             const prev = this._options.polygonStyle[name];
             if (prev === value)
                 return;
             this._options.polygonStyle[name] = value;
             if (name === "opacity") {
-                targetUBO.updateSingle("opacity", this._effectiveOpacity(target));
+                ubo.updateSingle("opacity", this._effectiveOpacity(target));
             }
             else {
-                targetUBO.updateSingle(name, value);
+                ubo.updateSingle(name, value);
             }
         }
         else {
-            targetUBO.updateSingle(name, value);
+            ubo.updateSingle(name, value);
         }
         this.globe.DrawRender();
     }
@@ -212,7 +206,7 @@ export class TerrainPolygonSemiPlugin {
             this._uboForRealEdgeArcs = this._program.createUBO();
             this._uboForRealEdgeArcs.updateSingle("defaultColor", new Float32Array(this._options.edgeStyle.defaultColor));
             this._uboForRealEdgeArcs.updateSingle("useDefaultColor", new Float32Array([this._options.edgeStyle.useDefaultColor ? 1 : 0]));
-            this._uboForRealEdgeArcs.updateSingle("pickedColor", new Float32Array(this._options.edgeStyle.pickedColor));
+            this._uboForRealEdgeArcs.updateSingle("hoverColor", new Float32Array(this._options.edgeStyle.hoverColor));
             this._uboForRealEdgeArcs.updateSingle("opacity", this._effectiveOpacity("edgeArc"));
             this._drawRealEdgeArcs.elementBuffer = this.globe.gl.createBuffer();
         }
@@ -226,6 +220,15 @@ export class TerrainPolygonSemiPlugin {
         this._options.drawEdges = state;
         this.globe.DrawRender();
     }
+    setUsePickedColorState(state, target = "polygon") {
+        const oldState = this._options[`${target}Style`].changePickedColor;
+        if (oldState === state)
+            return;
+        this._options[`${target}Style`].changePickedColor = state;
+        const ubo = this.__getUBO(target);
+        ubo.updateSingle("private_changeHoverColor", new Float32Array([state ? 1 : 0]));
+        this.globe.DrawRender();
+    }
     setOpacity(opacity) {
         if (this._options.opacity !== opacity) {
             this._options.opacity = opacity;
@@ -234,6 +237,15 @@ export class TerrainPolygonSemiPlugin {
             this.globe.DrawRender();
         }
     }
+    setChangeColorOnHoverState(state, target = "polygon") {
+        const oldState = this._options[`${target}Style`].changeHoverColor;
+        if (oldState === state)
+            return;
+        this._options[`${target}Style`].changeHoverColor = state;
+        const ubo = this.__getUBO(target);
+        ubo.updateSingle("private_changeHoverColor", new Float32Array([state ? 1 : 0]));
+        this.globe.DrawRender();
+    }
     setPausePickableState(state) {
         if (this._options.pickable === false) {
             throw new Error("TerrainPolygonSemiPlugin is not pickable. Set pickable option to true on construction to enable picking.");
@@ -254,7 +266,7 @@ export class TerrainPolygonSemiPlugin {
         if (oldState === false && state === true) {
             this._pickIndexBuffer = this.globe.gl.createBuffer();
             this._uboHandler.updateSingle("private_isPickedOn", new Float32Array([1.0]));
-            this._uboHandler.updateSingle("pickedColor", new Float32Array(this._options.polygonStyle.pickedColor));
+            this._uboHandler.updateSingle("hoverColor", new Float32Array(this._options.polygonStyle.hoverColor));
             this._pickerDisplayer = new PickerDisplayer(this.globe, "R32I");
         }
         else if (oldState === true && state === false) {
@@ -418,6 +430,19 @@ export class TerrainPolygonSemiPlugin {
             this.insertBulk(TestRecords.get(recordName));
         }
     }
+    __getUBO(target = "polygon") {
+        let targetUBO;
+        if (target === "polygon") {
+            targetUBO = this._uboHandler;
+        }
+        else if (target === "edgeArc") {
+            targetUBO = this._uboForRealEdgeArcs;
+        }
+        else {
+            throw new Error(`unknown target ${target} for __getUBO, must be "polygon" or "edgeArc"`);
+        }
+        return targetUBO;
+    }
 }
 function inputCheck(input) {
     if (!input.geometry || !Array.isArray(input.geometry) || input.geometry.length === 0) {

package/util/gl-util/buffer/attribute-loader.js

@@ -94,10 +94,9 @@ const setConstantAttribute = (gl, index, size, values, typeInfo) => {
         gl.vertexAttrib4f(index, v[0], v[1], v[2], v[3]);
 };
 function resetAttributeDefault(gl, index) {
-    gl.vertexAttrib4f(index, 1, 0, 0, 1);
+    gl.vertexAttrib4f(index, 0, 0, 0, 1);
 }
 function setDefaultAttributeValues(gl, index, size, escapeValues, typeInfo) {
-    // gl.disableVertexAttribArray(index);
     setConstantAttribute(gl, index, size, escapeValues, DATA_TYPE_MAP[typeInfo]);
 }
 export { attributeLoader, createBufferAndReadInfo, resetAttributeDefault, setDefaultAttributeValues };