@vitessce/neuroglancer 3.9.4 → 3.9.6

package/dist-tsc/shader-utils.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Generate a shader for spatialLayerColor encoding with no feature selection.
+ * All points get the static color.
+ * @param {[number, number, number]} staticColor RGB (0-255).
+ * @param {number} opacity Opacity (0-1).
+ * @returns {string} A GLSL shader string.
+ */
+export function getSpatialLayerColorShader(staticColor: [number, number, number], opacity: number): string;
+/**
+ * Generate a shader for spatialLayerColor encoding with feature selection.
+ * Selected features get the static color; unselected get the default color.
+ * @param {[number, number, number]} staticColor RGB (0-255).
+ * @param {number} opacity Opacity (0-1).
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {[number, number, number]} defaultColor RGB (0-255) for unselected points.
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getSpatialLayerColorWithSelectionShader(staticColor: [number, number, number], opacity: number, featureIndices: number[], defaultColor: [number, number, number], featureIndexProp: string): string;
+/**
+ * Generate a shader for spatialLayerColor encoding with feature selection
+ * and featureFilterMode='featureSelection' (hide unselected points).
+ * @param {[number, number, number]} staticColor RGB (0-255).
+ * @param {number} opacity Opacity (0-1).
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getSpatialLayerColorFilteredShader(staticColor: [number, number, number], opacity: number, featureIndices: number[], featureIndexProp: string): string;
+/**
+ * Generate a shader for geneSelection encoding with no feature selection.
+ * All points get the static color (since no features are selected to
+ * determine per-feature colors).
+ * @param {[number, number, number]} staticColor RGB (0-255).
+ * @param {number} opacity Opacity (0-1).
+ * @returns {string} A GLSL shader string.
+ */
+export function getGeneSelectionNoSelectionShader(staticColor: [number, number, number], opacity: number): string;
+/**
+ * Generate a shader for geneSelection encoding with feature selection.
+ * Each selected feature gets its color from featureColor; unselected
+ * points get the default color.
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {[number, number, number][]} featureColors RGB (0-255) for each
+ *   selected feature, in the same order as featureIndices.
+ * @param {[number, number, number]} staticColor Fallback RGB (0-255)
+ *   for selected features without a specified color.
+ * @param {[number, number, number]} defaultColor RGB (0-255) for
+ *   unselected points.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getGeneSelectionWithSelectionShader(featureIndices: number[], featureColors: [number, number, number][], staticColor: [number, number, number], defaultColor: [number, number, number], opacity: number, featureIndexProp: string): string;
+/**
+ * Generate a shader for geneSelection encoding with feature selection
+ * and featureFilterMode='featureSelection' (hide unselected points).
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {[number, number, number][]} featureColors RGB (0-255) for each
+ *   selected feature.
+ * @param {[number, number, number]} staticColor Fallback RGB (0-255).
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getGeneSelectionFilteredShader(featureIndices: number[], featureColors: [number, number, number][], staticColor: [number, number, number], opacity: number, featureIndexProp: string): string;
+/**
+ * Generate a shader for randomByFeature encoding with no feature selection.
+ * Each feature gets a deterministic color from PALETTE based on its index.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getRandomByFeatureShader(opacity: number, featureIndexProp: string): string;
+/**
+ * Generate a shader for randomByFeature encoding with feature selection.
+ * Selected features get their deterministic palette color; unselected
+ * points get the default color.
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {[number, number, number]} defaultColor RGB (0-255) for unselected.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getRandomByFeatureWithSelectionShader(featureIndices: number[], defaultColor: [number, number, number], opacity: number, featureIndexProp: string): string;
+/**
+ * Generate a shader for randomByFeature encoding with feature selection
+ * and featureFilterMode='featureSelection' (hide unselected points).
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getRandomByFeatureFilteredShader(featureIndices: number[], opacity: number, featureIndexProp: string): string;
+/**
+ * Generate a shader for random-per-point encoding with no feature selection.
+ * Each point gets a pseudo-random color based on its index.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @param {string} pointIndexProp The property name for the point index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getRandomPerPointShader(opacity: number, featureIndexProp: string, pointIndexProp: string): string;
+/**
+ * Generate a shader for random-per-point encoding with feature selection.
+ * Selected points get a pseudo-random color; unselected get the default color.
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {[number, number, number]} defaultColor RGB (0-255) for unselected.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @param {string} pointIndexProp The property name for the point index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getRandomPerPointWithSelectionShader(featureIndices: number[], defaultColor: [number, number, number], opacity: number, featureIndexProp: string, pointIndexProp: string): string;
+/**
+ * Generate a shader for random-per-point encoding with feature selection
+ * and featureFilterMode='featureSelection' (hide unselected points).
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @param {string} pointIndexProp The property name for the point index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getRandomPerPointFilteredShader(featureIndices: number[], opacity: number, featureIndexProp: string, pointIndexProp: string): string;
+export function getPointsShader(layerCoordination: any): string;
+//# sourceMappingURL=shader-utils.d.ts.map

package/dist-tsc/shader-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader-utils.d.ts","sourceRoot":"","sources":["../src/shader-utils.js"],"names":[],"mappings":"AAwCA;;;;;;GAMG;AACH,wDAJW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,WACxB,MAAM,GACJ,MAAM,CAUlB;AAGD;;;;;;;;;GASG;AACH,qEAPW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,WACxB,MAAM,kBACN,MAAM,EAAE,gBACR,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,oBACxB,MAAM,GACJ,MAAM,CA4BlB;AAGD;;;;;;;;GAQG;AACH,gEANW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,WACxB,MAAM,kBACN,MAAM,EAAE,oBACR,MAAM,GACJ,MAAM,CA0BlB;AAMD;;;;;;;GAOG;AACH,+DAJW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,WACxB,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;;GAcG;AACH,oEAXW,MAAM,EAAE,iBACR,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,eAE1B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,gBAExB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,WAExB,MAAM,oBACN,MAAM,GACJ,MAAM,CA+BlB;AAED;;;;;;;;;;GAUG;AACH,+DARW,MAAM,EAAE,iBACR,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,eAE1B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,WACxB,MAAM,oBACN,MAAM,GACJ,MAAM,CAoClB;AAMD;;;;;;GAMG;AACH,kDAJW,MAAM,oBACN,MAAM,GACJ,MAAM,CAkBlB;AAED;;;;;;;;;GASG;AACH,sEANW,MAAM,EAAE,gBACR,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,WACxB,MAAM,oBACN,MAAM,GACJ,MAAM,CAkClB;AAED;;;;;;;GAOG;AACH,iEALW,MAAM,EAAE,WACR,MAAM,oBACN,MAAM,GACJ,MAAM,CA8BlB;AAuBD;;;;;;;GAOG;AACH,iDALW,MAAM,oBACN,MAAM,kBACN,MAAM,GACJ,MAAM,CAelB;AAED;;;;;;;;;GASG;AACH,qEAPW,MAAM,EAAE,gBACR,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,WACxB,MAAM,oBACN,MAAM,kBACN,MAAM,GACJ,MAAM,CAgClB;AAED;;;;;;;;GAQG;AACH,gEANW,MAAM,EAAE,WACR,MAAM,oBACN,MAAM,kBACN,MAAM,GACJ,MAAM,CA8BlB;AAGD,gEAwKC"}

package/dist-tsc/shader-utils.js

@@ -0,0 +1,547 @@
+// Utilities for constructing shaders that
+// handle the coloring of Neuroglancer point annotation layers.
+// References:
+// - https://github.com/vitessce/vitessce/issues/2359#issuecomment-3572906947
+// - https://chanzuckerberg.github.io/cryoet-data-portal/stable/neuroglancer_quickstart.html
+import { PALETTE, getDefaultColor } from '@vitessce/utils';
+/**
+ * Normalize an RGB color array from [0, 255] to [0, 1].
+ * @param {[number, number, number]} rgbColor
+ * @returns {[number, number, number]}
+ */
+function normalizeColor(rgbColor) {
+    return rgbColor.map(c => c / 255);
+}
+/**
+ * Format a normalized color as a GLSL vec3 literal.
+ * @param {[number, number, number]} normalizedColor
+ * @returns {string}
+ */
+function toVec3(normalizedColor) {
+    return `vec3(${normalizedColor.join(', ')})`;
+}
+/**
+ * Format a normalized color as a GLSL vec4 literal.
+ * @param {[number, number, number]} normalizedColor
+ * @param {number} alpha
+ * @returns {string}
+ */
+function toVec4(normalizedColor, alpha) {
+    return `vec4(${normalizedColor.join(', ')}, ${alpha})`;
+}
+// ============================================================
+// Case 1: spatialLayerColor
+// ============================================================
+/**
+ * Generate a shader for spatialLayerColor encoding with no feature selection.
+ * All points get the static color.
+ * @param {[number, number, number]} staticColor RGB (0-255).
+ * @param {number} opacity Opacity (0-1).
+ * @returns {string} A GLSL shader string.
+ */
+export function getSpatialLayerColorShader(staticColor, opacity) {
+    const norm = normalizeColor(staticColor);
+    // lang: glsl
+    return `
+        void main() {
+            setColor(${toVec4(norm, opacity)});
+        }
+    `;
+}
+/**
+ * Generate a shader for spatialLayerColor encoding with feature selection.
+ * Selected features get the static color; unselected get the default color.
+ * @param {[number, number, number]} staticColor RGB (0-255).
+ * @param {number} opacity Opacity (0-1).
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {[number, number, number]} defaultColor RGB (0-255) for unselected points.
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getSpatialLayerColorWithSelectionShader(staticColor, opacity, featureIndices, defaultColor, featureIndexProp) {
+    const normStatic = normalizeColor(staticColor);
+    const normDefault = normalizeColor(defaultColor);
+    const numFeatures = featureIndices.length;
+    const indicesArr = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(', ')});`;
+    // lang: glsl
+    return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${indicesArr}
+            bool isSelected = false;
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                }
+            }
+            if (isSelected) {
+                setColor(${toVec4(normStatic, opacity)});
+            } else {
+                setColor(${toVec4(normDefault, opacity)});
+            }
+        }
+    `;
+}
+/**
+ * Generate a shader for spatialLayerColor encoding with feature selection
+ * and featureFilterMode='featureSelection' (hide unselected points).
+ * @param {[number, number, number]} staticColor RGB (0-255).
+ * @param {number} opacity Opacity (0-1).
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getSpatialLayerColorFilteredShader(staticColor, opacity, featureIndices, featureIndexProp) {
+    const normStatic = normalizeColor(staticColor);
+    const numFeatures = featureIndices.length;
+    const indicesArr = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(', ')});`;
+    // lang: glsl
+    return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${indicesArr}
+            bool isSelected = false;
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                }
+            }
+            if (!isSelected) {
+                discard;
+            }
+            setColor(${toVec4(normStatic, opacity)});
+        }
+    `;
+}
+// ============================================================
+// Case 2: geneSelection
+// ============================================================
+/**
+ * Generate a shader for geneSelection encoding with no feature selection.
+ * All points get the static color (since no features are selected to
+ * determine per-feature colors).
+ * @param {[number, number, number]} staticColor RGB (0-255).
+ * @param {number} opacity Opacity (0-1).
+ * @returns {string} A GLSL shader string.
+ */
+export function getGeneSelectionNoSelectionShader(staticColor, opacity) {
+    const norm = normalizeColor(staticColor);
+    // lang: glsl
+    return `
+        void main() {
+            setColor(${toVec4(norm, opacity)});
+        }
+    `;
+}
+/**
+ * Generate a shader for geneSelection encoding with feature selection.
+ * Each selected feature gets its color from featureColor; unselected
+ * points get the default color.
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {[number, number, number][]} featureColors RGB (0-255) for each
+ *   selected feature, in the same order as featureIndices.
+ * @param {[number, number, number]} staticColor Fallback RGB (0-255)
+ *   for selected features without a specified color.
+ * @param {[number, number, number]} defaultColor RGB (0-255) for
+ *   unselected points.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getGeneSelectionWithSelectionShader(featureIndices, featureColors, staticColor, defaultColor, opacity, featureIndexProp) {
+    const numFeatures = featureIndices.length;
+    const normDefault = normalizeColor(defaultColor);
+    const normColors = featureColors.map(c => normalizeColor(c));
+    const normStatic = normalizeColor(staticColor);
+    const colorArr = normColors.map(c => (c ? toVec3(c) : toVec3(normStatic)));
+    const indicesDecl = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(', ')});`;
+    const colorsDecl = `vec3 featureColors[${numFeatures}] = vec3[${numFeatures}](${colorArr.join(', ')});`;
+    // lang: glsl
+    return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${indicesDecl}
+            ${colorsDecl}
+            vec4 color = ${toVec4(normDefault, opacity)};
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    color = vec4(featureColors[i], ${opacity});
+                }
+            }
+            setColor(color);
+        }
+    `;
+}
+/**
+ * Generate a shader for geneSelection encoding with feature selection
+ * and featureFilterMode='featureSelection' (hide unselected points).
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {[number, number, number][]} featureColors RGB (0-255) for each
+ *   selected feature.
+ * @param {[number, number, number]} staticColor Fallback RGB (0-255).
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getGeneSelectionFilteredShader(featureIndices, featureColors, staticColor, opacity, featureIndexProp) {
+    const numFeatures = featureIndices.length;
+    const normColors = featureColors.map(c => normalizeColor(c));
+    const normStatic = normalizeColor(staticColor);
+    const colorArr = normColors.map(c => (c ? toVec3(c) : toVec3(normStatic)));
+    const indicesDecl = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(', ')});`;
+    const colorsDecl = `vec3 featureColors[${numFeatures}] = vec3[${numFeatures}](${colorArr.join(', ')});`;
+    // lang: glsl
+    return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${indicesDecl}
+            ${colorsDecl}
+            bool isSelected = false;
+            vec3 matchedColor = vec3(0.0);
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                    matchedColor = featureColors[i];
+                }
+            }
+            if (!isSelected) {
+                discard;
+            }
+            setColor(vec4(matchedColor, ${opacity}));
+        }
+    `;
+}
+// ============================================================
+// Case 3: randomByFeature
+// ============================================================
+/**
+ * Generate a shader for randomByFeature encoding with no feature selection.
+ * Each feature gets a deterministic color from PALETTE based on its index.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getRandomByFeatureShader(opacity, featureIndexProp) {
+    const paletteSize = PALETTE.length;
+    const normPalette = PALETTE.map(c => normalizeColor(c));
+    const paletteDecl = `vec3 palette[${paletteSize}] = vec3[${paletteSize}](${normPalette.map(c => toVec3(c)).join(', ')});`;
+    // lang: glsl
+    return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${paletteDecl}
+            int colorIdx = geneIndex - (geneIndex / ${paletteSize}) * ${paletteSize};
+            if (colorIdx < 0) { colorIdx = -colorIdx; }
+            vec3 color = palette[colorIdx];
+            setColor(vec4(color, ${opacity}));
+        }
+    `;
+}
+/**
+ * Generate a shader for randomByFeature encoding with feature selection.
+ * Selected features get their deterministic palette color; unselected
+ * points get the default color.
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {[number, number, number]} defaultColor RGB (0-255) for unselected.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getRandomByFeatureWithSelectionShader(featureIndices, defaultColor, opacity, featureIndexProp) {
+    const paletteSize = PALETTE.length;
+    const normPalette = PALETTE.map(c => normalizeColor(c));
+    const normDefault = normalizeColor(defaultColor);
+    const numFeatures = featureIndices.length;
+    const paletteDecl = `vec3 palette[${paletteSize}] = vec3[${paletteSize}](${normPalette.map(c => toVec3(c)).join(', ')});`;
+    const indicesDecl = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(', ')});`;
+    // lang: glsl
+    return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${paletteDecl}
+            ${indicesDecl}
+            bool isSelected = false;
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                }
+            }
+            if (isSelected) {
+                int colorIdx = geneIndex - (geneIndex / ${paletteSize}) * ${paletteSize};
+                if (colorIdx < 0) { colorIdx = -colorIdx; }
+                setColor(vec4(palette[colorIdx], ${opacity}));
+            } else {
+                setColor(${toVec4(normDefault, opacity)});
+            }
+        }
+    `;
+}
+/**
+ * Generate a shader for randomByFeature encoding with feature selection
+ * and featureFilterMode='featureSelection' (hide unselected points).
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getRandomByFeatureFilteredShader(featureIndices, opacity, featureIndexProp) {
+    const paletteSize = PALETTE.length;
+    const normPalette = PALETTE.map(c => normalizeColor(c));
+    const numFeatures = featureIndices.length;
+    const paletteDecl = `vec3 palette[${paletteSize}] = vec3[${paletteSize}](${normPalette.map(c => toVec3(c)).join(', ')});`;
+    const indicesDecl = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(', ')});`;
+    // lang: glsl
+    return `
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            ${paletteDecl}
+            ${indicesDecl}
+            bool isSelected = false;
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                }
+            }
+            if (!isSelected) {
+                discard;
+            }
+            int colorIdx = geneIndex - (geneIndex / ${paletteSize}) * ${paletteSize};
+            if (colorIdx < 0) { colorIdx = -colorIdx; }
+            setColor(vec4(palette[colorIdx], ${opacity}));
+        }
+    `;
+}
+// ============================================================
+// Case 4: random (per point)
+// ============================================================
+/**
+ * GLSL helper function that produces a pseudo-random float in [0, 1]
+ * from an integer value and a seed. Shared across random-per-point shaders.
+ * @returns {string} GLSL function source.
+ */
+function hashToFloatGlsl() {
+    return `
+        float hashToFloat(int v, int seed) {
+            int h = v ^ (seed * 16777619);
+            h = h * 747796405 + 2891336453;
+            h = ((h >> 16) ^ h) * 2654435769;
+            h = ((h >> 16) ^ h);
+            return float(h & 0x7FFFFFFF) / float(0x7FFFFFFF);
+        }
+    `;
+}
+/**
+ * Generate a shader for random-per-point encoding with no feature selection.
+ * Each point gets a pseudo-random color based on its index.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @param {string} pointIndexProp The property name for the point index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getRandomPerPointShader(opacity, featureIndexProp, pointIndexProp) {
+    // lang: glsl
+    return `
+        ${hashToFloatGlsl()}
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            int pointIndex = prop_${pointIndexProp}();
+            float r = hashToFloat(pointIndex, 0);
+            float g = hashToFloat(pointIndex, 1);
+            float b = hashToFloat(pointIndex, 2);
+            setColor(vec4(r, g, b, ${opacity}));
+        }
+    `;
+}
+/**
+ * Generate a shader for random-per-point encoding with feature selection.
+ * Selected points get a pseudo-random color; unselected get the default color.
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {[number, number, number]} defaultColor RGB (0-255) for unselected.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @param {string} pointIndexProp The property name for the point index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getRandomPerPointWithSelectionShader(featureIndices, defaultColor, opacity, featureIndexProp, pointIndexProp) {
+    const normDefault = normalizeColor(defaultColor);
+    const numFeatures = featureIndices.length;
+    const indicesDecl = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(', ')});`;
+    // lang: glsl
+    return `
+        ${hashToFloatGlsl()}
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            int pointIndex = prop_${pointIndexProp}();
+            ${indicesDecl}
+            bool isSelected = false;
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                }
+            }
+            if (isSelected) {
+                float r = hashToFloat(pointIndex, 0);
+                float g = hashToFloat(pointIndex, 1);
+                float b = hashToFloat(pointIndex, 2);
+                setColor(vec4(r, g, b, ${opacity}));
+            } else {
+                setColor(${toVec4(normDefault, opacity)});
+            }
+        }
+    `;
+}
+/**
+ * Generate a shader for random-per-point encoding with feature selection
+ * and featureFilterMode='featureSelection' (hide unselected points).
+ * @param {number[]} featureIndices Numeric indices of selected features.
+ * @param {number} opacity Opacity (0-1).
+ * @param {string} featureIndexProp The property name for the feature index in the shader.
+ * @param {string} pointIndexProp The property name for the point index in the shader.
+ * @returns {string} A GLSL shader string.
+ */
+export function getRandomPerPointFilteredShader(featureIndices, opacity, featureIndexProp, pointIndexProp) {
+    const numFeatures = featureIndices.length;
+    const indicesDecl = `int selectedIndices[${numFeatures}] = int[${numFeatures}](${featureIndices.join(', ')});`;
+    // lang: glsl
+    return `
+        ${hashToFloatGlsl()}
+        void main() {
+            int geneIndex = prop_${featureIndexProp}();
+            int pointIndex = prop_${pointIndexProp}();
+            ${indicesDecl}
+            bool isSelected = false;
+            for (int i = 0; i < ${numFeatures}; ++i) {
+                if (geneIndex == selectedIndices[i]) {
+                    isSelected = true;
+                }
+            }
+            if (!isSelected) {
+                discard;
+            }
+            float r = hashToFloat(pointIndex, 0);
+            float g = hashToFloat(pointIndex, 1);
+            float b = hashToFloat(pointIndex, 2);
+            setColor(vec4(r, g, b, ${opacity}));
+        }
+    `;
+}
+export function getPointsShader(layerCoordination) {
+    const { theme, featureIndex, spatialLayerOpacity, obsColorEncoding, spatialLayerColor, featureSelection, featureFilterMode, featureColor, featureIndexProp, pointIndexProp, } = layerCoordination;
+    const defaultColor = getDefaultColor(theme);
+    const opacity = spatialLayerOpacity ?? 1.0;
+    const staticColor = (Array.isArray(spatialLayerColor) && spatialLayerColor.length === 3
+        ? spatialLayerColor
+        : defaultColor);
+    const hasFeatureSelection = (Array.isArray(featureSelection) && featureSelection.length > 0);
+    const isFiltered = featureFilterMode === 'featureSelection';
+    // Resolve selected feature names to numeric indices.
+    let featureIndices = [];
+    if (hasFeatureSelection && Array.isArray(featureIndex)) {
+        featureIndices = featureSelection
+            .map(name => featureIndex.indexOf(name))
+            .filter(i => i >= 0);
+    }
+    const hasResolvedIndices = featureIndices.length > 0;
+    // Resolve per-feature colors (in the same order as featureIndices).
+    const resolvedFeatureColors = hasResolvedIndices
+        ? featureSelection
+            .filter(name => featureIndex?.indexOf(name) >= 0)
+            .map((name) => {
+            const match = Array.isArray(featureColor)
+                ? featureColor.find(fc => fc.name === name)?.color
+                : null;
+            return match || staticColor;
+        })
+        : [];
+    // Points coloring cases:
+    // (See `createPointLayer` in spatial-beta/Spatial.js for more background.)
+    // Coloring cases:
+    // - spatialLayerColor: one color for all points.
+    //   consider all as selected when featureSelection is null.
+    // - spatialLayerColor with featureSelection: one color for
+    //   all selected points, default color for unselected points
+    // - spatialLayerColor with featureSelection and
+    //   featureFilterMode 'featureSelection': one color for selected points,
+    //   do not show unselected points
+    // - geneSelection: use colors from "featureColor".
+    //   consider all as selected when featureSelection is null.
+    // - geneSelection with featureSelection: use colors from
+    //   "featureColor" (array of { name, color: [r, g, b] }) for
+    //   selected features, default color for unselected points
+    // - geneSelection with featureFilterMode 'featureSelection': use colors
+    //   from "featureColor" for selected features,
+    //   do not show unselected points
+    // - randomByFeature: random color for each feature
+    //   (deterministic based on feature index).
+    //   consider all as selected when featureSelection is null.
+    // - randomByFeature with preferFeatureColor: use colors from
+    //   "featureColor" (array of { name, color: [r, g, b] }) where
+    //   available, and random colors otherwise.
+    // - randomByFeature with featureSelection: random color for
+    //   selected features, default color for unselected points
+    // - randomByFeature with featureSelection and
+    //   featureFilterMode 'featureSelection': random color for
+    //   selected features, do not show unselected points
+    // - random: random color for each point
+    //   (deterministic based on point index).
+    //   consider all as selected when featureSelection is null.
+    // - random with preferFeatureColor: use colors from "featureColor"
+    //   (array of { name, color: [r, g, b] }) where available,
+    //   and random colors otherwise.
+    // - random with featureSelection: random color for selected points,
+    //   default color for unselected points
+    // - random with featureSelection and
+    //   featureFilterMode 'featureSelection': random color for selected
+    //   points, do not show unselected points
+    // ---- spatialLayerColor ----
+    if (obsColorEncoding === 'spatialLayerColor') {
+        if (!hasFeatureSelection || !hasResolvedIndices) {
+            return getSpatialLayerColorShader(staticColor, opacity);
+        }
+        if (isFiltered) {
+            return getSpatialLayerColorFilteredShader(staticColor, opacity, featureIndices, featureIndexProp);
+        }
+        return getSpatialLayerColorWithSelectionShader(staticColor, opacity, featureIndices, defaultColor, featureIndexProp);
+    }
+    // ---- geneSelection ----
+    if (obsColorEncoding === 'geneSelection') {
+        if (!featureIndexProp) {
+            throw new Error('In order to use gene-based color encoding for Neuroglancer Points, options.featureIndexProp must be specified for the obsPoints.ng-annotations fileType in the Vitessce configuration.');
+        }
+        if (!hasFeatureSelection || !hasResolvedIndices) {
+            return getGeneSelectionNoSelectionShader(staticColor, opacity);
+        }
+        if (isFiltered) {
+            return getGeneSelectionFilteredShader(featureIndices, resolvedFeatureColors, staticColor, opacity, featureIndexProp);
+        }
+        return getGeneSelectionWithSelectionShader(featureIndices, resolvedFeatureColors, staticColor, defaultColor, opacity, featureIndexProp);
+    }
+    // ---- randomByFeature ----
+    if (obsColorEncoding === 'randomByFeature') {
+        if (!featureIndexProp) {
+            throw new Error('In order to use gene-based color encoding for Neuroglancer Points, options.featureIndexProp must be specified for the obsPoints.ng-annotations fileType in the Vitessce configuration.');
+        }
+        if (!hasFeatureSelection || !hasResolvedIndices) {
+            return getRandomByFeatureShader(opacity, featureIndexProp);
+        }
+        if (isFiltered) {
+            return getRandomByFeatureFilteredShader(featureIndices, opacity, featureIndexProp);
+        }
+        return getRandomByFeatureWithSelectionShader(featureIndices, defaultColor, opacity, featureIndexProp);
+    }
+    // ---- random (per point) ----
+    if (obsColorEncoding === 'random') {
+        if (!pointIndexProp) {
+            throw new Error('In order to use per-point color encoding for Neuroglancer Points, options.pointIndexProp must be specified for the obsPoints.ng-annotations fileType in the Vitessce configuration.');
+        }
+        if (!hasFeatureSelection || !hasResolvedIndices) {
+            return getRandomPerPointShader(opacity, featureIndexProp, pointIndexProp);
+        }
+        if (isFiltered) {
+            return getRandomPerPointFilteredShader(featureIndices, opacity, featureIndexProp, pointIndexProp);
+        }
+        return getRandomPerPointWithSelectionShader(featureIndices, defaultColor, opacity, featureIndexProp, pointIndexProp);
+    }
+    // Fallback: static color.
+    return getSpatialLayerColorShader(staticColor, opacity);
+}

package/dist-tsc/shader-utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shader-utils.test.d.ts.map