astro-viewer 3.13.1 → 3.14.0

package/dist/astroviewer.js

@@ -9518,12 +9518,19 @@ class CatalogueGL {
         if (this._catalogueShaderProgram.locations.color) {
             this._webgl.uniform4f(this._catalogueShaderProgram.locations.color, rgb[0], rgb[1], rgb[2], 1.0);
         }
-        const interactionColors = (0, Utils_js_1.interactionColorsFromHex)(this._shapeColor);
+        // const interactionColors = interactionColorsFromHex(this._shapeColor);
+        // Complementary RGB colour for catalogue interactions.
+        // Keep the original catalogue colour unchanged.
+        const complementaryColor = rgb.map((component) => 1.0 - component);
         if (this._catalogueShaderProgram.locations.hoverColor) {
-            this._webgl.uniform4f(this._catalogueShaderProgram.locations.hoverColor, ...interactionColors.hover, 1.0);
+            this._webgl.uniform4f(this._catalogueShaderProgram.locations.hoverColor, 
+            // ...interactionColors.hover,
+            ...complementaryColor, 1.0);
         }
         if (this._catalogueShaderProgram.locations.selectedColor) {
-            this._webgl.uniform4f(this._catalogueShaderProgram.locations.selectedColor, ...interactionColors.selected, 1.0);
+            this._webgl.uniform4f(this._catalogueShaderProgram.locations.selectedColor, 
+            // ...interactionColors.selected,
+            ...complementaryColor, 1.0);
         }
         // selected flags
         for (let s = 0; s < this.selectedIndexes.length; s++) {
@@ -11186,6 +11193,8 @@ class FootprintSetGL {
     hoveredIndexBuffer;
     selectedVertexPositionBuffer;
     selectedIndexBuffer;
+    selectedFillBuffer;
+    selectedFillVertices = new Float32Array(0);
     indexes;
     footprintPolygons = [];
     vertexCataloguePosition;
@@ -11241,6 +11250,7 @@ class FootprintSetGL {
         this.totSelectedPoints = 0;
         this.selectedIndexes = [];
         this.selectedElementIndexes = new Uint32Array();
+        this.selectedFillVertices = new Float32Array();
     }
     initGLBuffers() {
         if (!this._webgl)
@@ -11251,6 +11261,7 @@ class FootprintSetGL {
         this.hoveredIndexBuffer = this._webgl.createBuffer();
         this.selectedVertexPositionBuffer = this._webgl.createBuffer();
         this.selectedIndexBuffer = this._webgl.createBuffer();
+        this.selectedFillBuffer = this._webgl.createBuffer();
     }
     setIsVisible(visibility) {
         this._isVisible = visibility;
@@ -11428,9 +11439,11 @@ class FootprintSetGL {
             this.selectedVertexPosition = new Float32Array();
             this.selectedElementIndexes = new Uint32Array();
             this.nSlectedPrimitiveFlags = 0;
+            this.selectedFillVertices = new Float32Array();
             return;
         }
         this.initSelectionBuffer();
+        this.selectedFillVertices = this.buildSelectedFillVertices();
     }
     getFootprintsFromPointer(in_mouseHelper) {
         const pickedIndexes = this.checkClicking(in_mouseHelper);
@@ -11683,6 +11696,70 @@ class FootprintSetGL {
             }
         }
     }
+    /** Triangulate selected simple rings in the same 2D projection used for picking.
+     * A failed/degenerate ring is left unfilled; its outline remains visible.
+     */
+    buildSelectedFillVertices() {
+        const vertices = [];
+        const cross = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+        for (const footprint of this._selectedFootprints) {
+            const projected = footprint.selectionObj?.poly4selection;
+            if (!projected)
+                continue;
+            footprint.polygons.forEach((ring, ringIndex) => {
+                const coords = projected[ringIndex];
+                if (!coords || coords.length !== ring.length || ring.length < 3)
+                    return;
+                const indices = ring.map((_, i) => i);
+                // STC-S normally omits the duplicated closing vertex; fromPolygons may not.
+                if (indices.length > 3 &&
+                    Math.abs(coords[0].x - coords[indices[indices.length - 1]].x) < 1e-12 &&
+                    Math.abs(coords[0].y - coords[indices[indices.length - 1]].y) < 1e-12)
+                    indices.pop();
+                if (indices.length < 3)
+                    return;
+                const area = indices.reduce((sum, idx, i) => {
+                    const next = indices[(i + 1) % indices.length];
+                    return sum + coords[idx].x * coords[next].y - coords[next].x * coords[idx].y;
+                }, 0);
+                if (Math.abs(area) < 1e-14)
+                    return;
+                const orientation = Math.sign(area);
+                const triangles = [];
+                let attempts = 0;
+                while (indices.length > 3 && attempts++ < ring.length * ring.length) {
+                    let clipped = false;
+                    for (let i = 0; i < indices.length; i++) {
+                        const a = indices[(i + indices.length - 1) % indices.length];
+                        const b = indices[i];
+                        const c = indices[(i + 1) % indices.length];
+                        if (orientation * cross(coords[a], coords[b], coords[c]) <= 1e-14)
+                            continue;
+                        const contains = indices.some(idx => idx !== a && idx !== b && idx !== c &&
+                            orientation * cross(coords[a], coords[b], coords[idx]) >= -1e-14 &&
+                            orientation * cross(coords[b], coords[c], coords[idx]) >= -1e-14 &&
+                            orientation * cross(coords[c], coords[a], coords[idx]) >= -1e-14);
+                        if (contains)
+                            continue;
+                        triangles.push(a, b, c);
+                        indices.splice(i, 1);
+                        clipped = true;
+                        break;
+                    }
+                    if (!clipped)
+                        break;
+                }
+                if (indices.length !== 3)
+                    return;
+                triangles.push(...indices);
+                for (const idx of triangles) {
+                    const point = ring[idx];
+                    vertices.push(point.x, point.y, point.z);
+                }
+            });
+        }
+        return new Float32Array(vertices);
+    }
     changeColor(color) {
         this._shapeColor = color;
     }
@@ -11699,11 +11776,6 @@ class FootprintSetGL {
         if (!this._webgl)
             return;
         this._footprintShaderProgram.enableShaders(pMatrix, in_mMatrix, vMatrix);
-        // this._footprintShaderProgram.enableShaders(
-        //   computePerspectiveMatrixSingleton.pMatrix as Float32Array,
-        //   in_mMatrix,
-        //   vMatrix
-        // )
         if (in_mouseHelper != null && in_mouseHelper.xyz != this.oldMouseCoords) {
             this.checkSelection(in_mouseHelper);
         }
@@ -11726,6 +11798,31 @@ class FootprintSetGL {
         }
         if (this._selectedFootprints.length > 0) {
             const rgb = interactionColors.selected;
+            if (this.selectedFillVertices.length > 0) {
+                this._webgl.uniform4f(this._footprintShaderProgram.locations.color, rgb[0], rgb[1], rgb[2], 0.25);
+                this._webgl.bindBuffer(this._webgl.ARRAY_BUFFER, this.selectedFillBuffer);
+                this._webgl.bufferData(this._webgl.ARRAY_BUFFER, this.selectedFillVertices, this._webgl.DYNAMIC_DRAW);
+                this._webgl.vertexAttribPointer(this._footprintShaderProgram.locations.position, FootprintSetGL.ELEM_SIZE, this._webgl.FLOAT, false, FootprintSetGL.BYTES_X_ELEM * FootprintSetGL.ELEM_SIZE, 0);
+                this._webgl.enableVertexAttribArray(this._footprintShaderProgram.locations.position);
+                // Keep translucent fills from writing depth and push them slightly
+                // behind the outlines. Preserve the incoming GL state.
+                const previousDepthMask = this._webgl.getParameter(this._webgl.DEPTH_WRITEMASK);
+                const previousOffsetEnabled = this._webgl.isEnabled(this._webgl.POLYGON_OFFSET_FILL);
+                const previousOffsetFactor = this._webgl.getParameter(this._webgl.POLYGON_OFFSET_FACTOR);
+                const previousOffsetUnits = this._webgl.getParameter(this._webgl.POLYGON_OFFSET_UNITS);
+                this._webgl.depthMask(false);
+                this._webgl.enable(this._webgl.POLYGON_OFFSET_FILL);
+                this._webgl.polygonOffset(1, 1);
+                try {
+                    this._webgl.drawArrays(this._webgl.TRIANGLES, 0, this.selectedFillVertices.length / FootprintSetGL.ELEM_SIZE);
+                }
+                finally {
+                    this._webgl.depthMask(previousDepthMask);
+                    this._webgl.polygonOffset(previousOffsetFactor, previousOffsetUnits);
+                    if (!previousOffsetEnabled)
+                        this._webgl.disable(this._webgl.POLYGON_OFFSET_FILL);
+                }
+            }
             const alpha = 1.0;
             this._webgl.uniform4f(this._footprintShaderProgram.locations.color, rgb[0], rgb[1], rgb[2], alpha);
             this._webgl.uniform1f(this._footprintShaderProgram.locations.pointSize, 14.0); // <--- POINT_SIZE in LINE_LOOP is not applicable
@@ -18536,14 +18633,29 @@ class ShaderManager {
         alpha = 1.0 - smoothstep(1.0 - delta, 1.0 + delta, r);
       #endif
 
-      if (v_selected == 1.0){
-        fragColor = u_hovercolor * alpha;
-      } else if (v_selected == 2.0){
-        // Persistent selection: keep the dataset colour as an outer ring
-        // and use the hover colour for the fill. This remains visible for
-        // both light and dark user-selected base colours.
+      if (v_selected == 1.0) {
+        // Hover: original catalogue colour on the outer ring,
+        // complementary colour in the centre.
         fragColor = (r > 0.72 ? u_fragcolor : u_hovercolor) * alpha;
-      }else{
+
+      } else if (v_selected == 2.0) {
+        // Selected: same ring and fill, plus a contrasting centre dot.
+        if (r < 0.09) {
+          float luminance = dot(
+            u_selectedcolor.rgb,
+            vec3(0.2126, 0.7152, 0.0722)
+          );
+
+          vec3 dotColor = luminance > 0.5
+            ? vec3(0.0)
+            : vec3(1.0);
+
+          fragColor = vec4(dotColor, 1.0) * alpha;
+        } else {
+          fragColor = (r > 0.72 ? u_fragcolor : u_selectedcolor) * alpha;
+        }
+
+      } else {
         if (r < 0.4) {
           discard;
         }
@@ -20346,7 +20458,7 @@ function interactionColorsFromHex(hexColor) {
     ];
     return {
         hover: mix(0.45),
-        selected: mix(0.45),
+        selected: mix(0.75),
     };
 }
 function degToRad(degrees) {