astro-viewer 1.3.0

package/lib-esm/shader/ShaderManagerMutliHiPS.js

@@ -0,0 +1,750 @@
+// ShaderManagerMultiHiPS.ts
+export default class ShaderManagerMultiHiPS {
+    static hipsVS() {
+        return `#version 300 es
+    in vec3 aVertexPosition;
+    in vec2 aTextureCoord;
+
+    uniform mat4 uMMatrix;
+    uniform mat4 uVMatrix;
+    uniform mat4 uPMatrix;
+
+    out vec2 vTextureCoord;
+
+    void main() {
+      gl_Position = uPMatrix * uVMatrix * uMMatrix * vec4(aVertexPosition, 1.0);
+      vTextureCoord = aTextureCoord;
+    }`;
+    }
+    static hipsNativeFS() {
+        return `#version 300 es
+    precision mediump float;
+
+    in vec2 vTextureCoord;
+
+    uniform sampler2D uSampler0;
+    uniform sampler2D uSampler1;
+    uniform sampler2D uSampler2;
+    uniform sampler2D uSampler3;
+    uniform sampler2D uSampler4;
+    uniform sampler2D uSampler5;
+    uniform sampler2D uSampler6;
+    uniform sampler2D uSampler7;
+
+    uniform float uFactor0;
+    uniform float uFactor1;
+    uniform float uFactor2;
+    uniform float uFactor3;
+    uniform float uFactor4;
+    uniform float uFactor5;
+    uniform float uFactor6;
+    uniform float uFactor7;
+
+    out vec4 fragColor;
+
+    void main() {
+      vec3 finalColor = vec3(0.0);
+
+      if (uFactor0 >= 0.0){
+        vec4 mycolor;
+        #if __VERSION__ > 120
+          vec4 color0 = texture(uSampler0, vTextureCoord);
+        #else
+          vec4 color0 = texture2D(uSampler0, vTextureCoord);
+        #endif
+        mycolor = color0;
+        finalColor += mycolor.rgb * uFactor0;
+      } else if (uFactor7 >= 0.0){
+        finalColor = vec3(1.0, 0.0, 0.0);
+      }
+      fragColor = vec4(finalColor, 1.0);
+    }`;
+    }
+    static hipsGrayscaleFS() {
+        return `#version 300 es
+    precision mediump float;
+
+    in vec2 vTextureCoord;
+
+    uniform sampler2D uSampler0;
+    uniform sampler2D uSampler1;
+    uniform sampler2D uSampler2;
+    uniform sampler2D uSampler3;
+    uniform sampler2D uSampler4;
+    uniform sampler2D uSampler5;
+    uniform sampler2D uSampler6;
+    uniform sampler2D uSampler7;
+
+    uniform float uFactor0;
+    uniform float uFactor1;
+    uniform float uFactor2;
+    uniform float uFactor3;
+    uniform float uFactor4;
+    uniform float uFactor5;
+    uniform float uFactor6;
+    uniform float uFactor7;
+
+    out vec4 fragColor;
+
+    void main() {
+      vec3 finalColor = vec3(0.0);
+
+      if (uFactor0 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color0 = texture(uSampler0, vTextureCoord);
+        #else
+          vec4 color0 = texture2D(uSampler0, vTextureCoord);
+        #endif
+        float gray = 0.21 * color0.r + 0.71 * color0.g + 0.07 * color0.b;
+        finalColor = color0.rgb * (1.0 - uFactor0) + vec3(gray) * uFactor0;
+      }
+      if (uFactor1 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color1 = texture(uSampler1, vTextureCoord);
+        #else
+          vec4 color1 = texture2D(uSampler1, vTextureCoord);
+        #endif
+        finalColor += color1.rgb * uFactor1;
+      }
+      if (uFactor2 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color2 = texture(uSampler2, vTextureCoord);
+        #else
+          vec4 color2 = texture2D(uSampler2, vTextureCoord);
+        #endif
+        finalColor += color2.rgb * uFactor2;
+      }
+      if (uFactor3 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color3 = texture(uSampler3, vTextureCoord);
+        #else
+          vec4 color3 = texture2D(uSampler3, vTextureCoord);
+        #endif
+        finalColor += color3.rgb * uFactor3;
+      }
+      if (uFactor4 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color4 = texture(uSampler4, vTextureCoord);
+        #else
+          vec4 color4 = texture2D(uSampler4, vTextureCoord);
+        #endif
+        finalColor += color4.rgb * uFactor4;
+      }
+      if (uFactor5 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color5 = texture(uSampler5, vTextureCoord);
+        #else
+          vec4 color5 = texture2D(uSampler5, vTextureCoord);
+        #endif
+        finalColor += color5.rgb * uFactor5;
+      }
+      if (uFactor6 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color6 = texture(uSampler6, vTextureCoord);
+        #else
+          vec4 color6 = texture2D(uSampler6, vTextureCoord);
+        #endif
+        finalColor += color6.rgb * uFactor6;
+      }
+      if (uFactor7 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color7 = texture(uSampler7, vTextureCoord);
+        #else
+          vec4 color7 = texture2D(uSampler7, vTextureCoord);
+        #endif
+        finalColor += color7.rgb * uFactor7;
+      }
+      fragColor = vec4(finalColor, 1.0);
+    }`;
+    }
+    static hipsPlanckFS() {
+        return `#version 300 es
+    precision mediump float;
+
+    in vec2 vTextureCoord;
+
+    uniform sampler2D uSampler0;
+    uniform sampler2D uSampler1;
+    uniform sampler2D uSampler2;
+    uniform sampler2D uSampler3;
+    uniform sampler2D uSampler4;
+    uniform sampler2D uSampler5;
+    uniform sampler2D uSampler6;
+    uniform sampler2D uSampler7;
+
+    uniform float uFactor0;
+    uniform float uFactor1;
+    uniform float uFactor2;
+    uniform float uFactor3;
+    uniform float uFactor4;
+    uniform float uFactor5;
+    uniform float uFactor6;
+    uniform float uFactor7;
+
+    out vec4 fragColor;
+
+    struct colormap {
+      float r[256];
+      float g[256];
+      float b[256];
+    } planck;
+
+    colormap planckCMap() {
+      // (omitted for brevity – identical table content as your JS version)
+      planck.r = float[256](0.00000, 0.769231, 1.53846, 2.30769, 3.07692, 3.84615, 4.61538, 5.38462, 6.15385, 6.92308, 7.69231, 8.46154,
+      9.23077, 10.0000, 11.5385, 13.0769, 14.6154, 16.1538, 17.6923, 19.2308, 20.7692, 22.3077, 23.8462, 25.3846,
+      26.9231, 28.4615, 30.0000, 33.8462, 37.6923, 41.5385, 45.3846, 49.2308, 53.0769, 56.9231, 60.7692, 64.6154,
+      68.4615, 72.3077, 76.1538, 80.0000, 88.5385, 97.0769, 105.615, 114.154, 122.692, 131.231, 139.769, 148.308,
+      156.846, 165.385, 173.923, 182.462, 191.000, 193.846, 196.692, 199.538, 202.385, 205.231, 208.077, 210.923,
+      213.769, 216.615, 219.462, 222.308, 225.154, 228.000, 229.182, 230.364, 231.545, 232.727, 233.909, 235.091,
+      236.273, 237.455, 238.636, 239.818, 241.000, 241.000, 241.364, 241.727, 242.091, 242.455, 242.818, 243.182,
+      243.545, 243.909, 244.273, 244.636, 245.000, 245.231, 245.462, 245.692, 245.923, 246.154, 246.385, 246.615,
+      246.846, 247.077, 247.308, 247.538, 247.769, 248.000, 248.146, 248.292, 248.438, 248.585, 248.731, 248.877,
+      249.023, 249.169, 249.315, 249.462, 249.608, 249.754, 249.900, 249.312, 248.723, 248.135, 247.546, 246.958,
+      246.369, 245.781, 245.192, 244.604, 244.015, 243.427, 242.838, 242.250, 239.308, 236.365, 233.423, 230.481,
+      227.538, 224.596, 221.654, 218.712, 215.769, 212.827, 209.885, 206.942, 204.000, 201.000, 198.000, 195.000,
+      192.000, 189.000, 186.000, 183.000, 180.000, 177.000, 174.000, 171.000, 168.000, 165.000, 161.077, 157.154,
+      153.231, 149.308, 145.385, 141.462, 137.538, 133.615, 129.692, 125.769, 121.846, 117.923, 114.000, 115.038,
+      116.077, 117.115, 118.154, 119.192, 120.231, 121.269, 122.308, 123.346, 124.385, 125.423, 126.462, 127.500,
+      131.423, 135.346, 139.269, 143.192, 147.115, 151.038, 154.962, 158.885, 162.808, 166.731, 170.654, 174.577,
+      178.500, 180.462, 182.423, 184.385, 186.346, 188.308, 190.269, 192.231, 194.192, 196.154, 198.115, 200.077,
+      202.038, 204.000, 205.962, 207.923, 209.885, 211.846, 213.808, 215.769, 217.731, 219.692, 221.654, 223.615,
+      225.577, 227.538, 229.500, 230.481, 231.462, 232.442, 233.423, 234.404, 235.385, 236.365, 237.346, 238.327,
+      239.308, 240.288, 241.269, 242.250, 242.642, 243.035, 243.427, 243.819, 244.212, 244.604, 244.996, 245.388,
+      245.781, 246.173, 246.565, 246.958, 247.350, 247.814, 248.277, 248.741, 249.205, 249.668, 250.132, 250.595,
+      251.059, 251.523, 251.986, 252.450);
+      planck.g = float[256](/* full array unchanged */);
+      planck.b = float[256](/* full array unchanged */);
+      return planck;
+    }
+
+    void main() {
+      vec3 finalColor = vec3(0.0);
+
+      if (uFactor0 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color0 = texture(uSampler0, vTextureCoord);
+        #else
+          vec4 color0 = texture2D(uSampler0, vTextureCoord);
+        #endif
+        colormap t = planckCMap();
+        int x = int(floor(color0.r * 256.0));
+        int y = int(floor(color0.g * 256.0));
+        int z = int(floor(color0.b * 256.0));
+        vec3 mapped = vec3(t.r[x], t.g[y], t.b[z]) / 256.0;
+        finalColor += mapped * uFactor0;
+      }
+      if (uFactor1 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color1 = texture(uSampler1, vTextureCoord);
+        #else
+          vec4 color1 = texture2D(uSampler1, vTextureCoord);
+        #endif
+        finalColor += color1.rgb * uFactor1;
+      }
+      if (uFactor2 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color2 = texture(uSampler2, vTextureCoord);
+        #else
+          vec4 color2 = texture2D(uSampler2, vTextureCoord);
+        #endif
+        finalColor += color2.rgb * uFactor2;
+      }
+      if (uFactor3 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color3 = texture(uSampler3, vTextureCoord);
+        #else
+          vec4 color3 = texture2D(uSampler3, vTextureCoord);
+        #endif
+        finalColor += color3.rgb * uFactor3;
+      }
+      if (uFactor4 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color4 = texture(uSampler4, vTextureCoord);
+        #else
+          vec4 color4 = texture2D(uSampler4, vTextureCoord);
+        #endif
+        finalColor += color4.rgb * uFactor4;
+      }
+      if (uFactor5 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color5 = texture(uSampler5, vTextureCoord);
+        #else
+          vec4 color5 = texture2D(uSampler5, vTextureCoord);
+        #endif
+        finalColor += color5.rgb * uFactor5;
+      }
+      if (uFactor6 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color6 = texture(uSampler6, vTextureCoord);
+        #else
+          vec4 color6 = texture2D(uSampler6, vTextureCoord);
+        #endif
+        finalColor += color6.rgb * uFactor6;
+      }
+      if (uFactor7 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color7 = texture(uSampler7, vTextureCoord);
+        #else
+          vec4 color7 = texture2D(uSampler7, vTextureCoord);
+        #endif
+        finalColor += color7.rgb * uFactor7;
+      }
+      fragColor = vec4(finalColor, 1.0);
+    }`;
+    }
+    static hipsCmbFS() {
+        return `#version 300 es
+    precision mediump float;
+
+    in vec2 vTextureCoord;
+
+    uniform sampler2D uSampler0;
+    uniform sampler2D uSampler1;
+    uniform sampler2D uSampler2;
+    uniform sampler2D uSampler3;
+    uniform sampler2D uSampler4;
+    uniform sampler2D uSampler5;
+    uniform sampler2D uSampler6;
+    uniform sampler2D uSampler7;
+
+    uniform float uFactor0;
+    uniform float uFactor1;
+    uniform float uFactor2;
+    uniform float uFactor3;
+    uniform float uFactor4;
+    uniform float uFactor5;
+    uniform float uFactor6;
+    uniform float uFactor7;
+
+    uniform int cmapIdx;
+    uniform float uSphericalGrid;
+
+    out vec4 fragColor;
+
+    struct colormap { float r[256]; float g[256]; float b[256]; } cmb;
+
+    colormap cmbCMap() {
+      // full tables identical to your JS version
+      cmb.r = float[256](/* ... */);
+      cmb.g = float[256](/* ... */);
+      cmb.b = float[256](/* ... */);
+      return cmb;
+    }
+
+    void main() {
+      vec3 finalColor = vec3(0.0);
+
+      if (uFactor0 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color0 = texture(uSampler0, vTextureCoord);
+        #else
+          vec4 color0 = texture2D(uSampler0, vTextureCoord);
+        #endif
+        colormap t = cmbCMap();
+        int x = int(floor(color0.r * 256.0));
+        int y = int(floor(color0.g * 256.0));
+        int z = int(floor(color0.b * 256.0));
+        vec3 mapped = vec3(t.r[x], t.g[y], t.b[z]) / 256.0;
+        finalColor += mapped * uFactor0;
+      }
+      if (uFactor1 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color1 = texture(uSampler1, vTextureCoord);
+        #else
+          vec4 color1 = texture2D(uSampler1, vTextureCoord);
+        #endif
+        finalColor += color1.rgb * uFactor1;
+      }
+      if (uFactor2 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color2 = texture(uSampler2, vTextureCoord);
+        #else
+          vec4 color2 = texture2D(uSampler2, vTextureCoord);
+        #endif
+        finalColor += color2.rgb * uFactor2;
+      }
+      if (uFactor3 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color3 = texture(uSampler3, vTextureCoord);
+        #else
+          vec4 color3 = texture2D(uSampler3, vTextureCoord);
+        #endif
+        finalColor += color3.rgb * uFactor3;
+      }
+      if (uFactor4 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color4 = texture(uSampler4, vTextureCoord);
+        #else
+          vec4 color4 = texture2D(uSampler4, vTextureCoord);
+        #endif
+        finalColor += color4.rgb * uFactor4;
+      }
+      if (uFactor5 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color5 = texture(uSampler5, vTextureCoord);
+        #else
+          vec4 color5 = texture2D(uSampler5, vTextureCoord);
+        #endif
+        finalColor += color5.rgb * uFactor5;
+      }
+      if (uFactor6 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color6 = texture(uSampler6, vTextureCoord);
+        #else
+          vec4 color6 = texture2D(uSampler6, vTextureCoord);
+        #endif
+        finalColor += color6.rgb * uFactor6;
+      }
+      if (uFactor7 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color7 = texture(uSampler7, vTextureCoord);
+        #else
+          vec4 color7 = texture2D(uSampler7, vTextureCoord);
+        #endif
+        finalColor += color7.rgb * uFactor7;
+      }
+      fragColor = vec4(finalColor, 1.0);
+    }`;
+    }
+    static hipsRainbowFS() {
+        return `#version 300 es
+    precision mediump float;
+
+    in vec2 vTextureCoord;
+
+    uniform sampler2D uSampler0;
+    uniform sampler2D uSampler1;
+    uniform sampler2D uSampler2;
+    uniform sampler2D uSampler3;
+    uniform sampler2D uSampler4;
+    uniform sampler2D uSampler5;
+    uniform sampler2D uSampler6;
+    uniform sampler2D uSampler7;
+
+    uniform float uFactor0;
+    uniform float uFactor1;
+    uniform float uFactor2;
+    uniform float uFactor3;
+    uniform float uFactor4;
+    uniform float uFactor5;
+    uniform float uFactor6;
+    uniform float uFactor7;
+
+    uniform int cmapIdx;
+    uniform float uSphericalGrid;
+
+    out vec4 fragColor;
+
+    struct colormap { float r[256]; float g[256]; float b[256]; } rainbow;
+
+    colormap rainbowCMap() {
+      rainbow.r = float[256](/* full table unchanged */);
+      rainbow.g = float[256](/* full table unchanged */);
+      rainbow.b = float[256](/* full table unchanged */);
+      return rainbow;
+    }
+
+    void main() {
+      vec3 finalColor = vec3(0.0);
+
+      if (uFactor0 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color0 = texture(uSampler0, vTextureCoord);
+        #else
+          vec4 color0 = texture2D(uSampler0, vTextureCoord);
+        #endif
+        colormap t = rainbowCMap();
+        int x = int(floor(color0.r * 256.0));
+        int y = int(floor(color0.g * 256.0));
+        int z = int(floor(color0.b * 256.0));
+        vec3 mapped = vec3(t.r[x], t.g[y], t.b[z]) / 256.0;
+        finalColor += mapped * uFactor0;
+      }
+      if (uFactor1 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color1 = texture(uSampler1, vTextureCoord);
+        #else
+          vec4 color1 = texture2D(uSampler1, vTextureCoord);
+        #endif
+        finalColor += color1.rgb * uFactor1;
+      }
+      if (uFactor2 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color2 = texture(uSampler2, vTextureCoord);
+        #else
+          vec4 color2 = texture2D(uSampler2, vTextureCoord);
+        #endif
+        finalColor += color2.rgb * uFactor2;
+      }
+      if (uFactor3 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color3 = texture(uSampler3, vTextureCoord);
+        #else
+          vec4 color3 = texture2D(uSampler3, vTextureCoord);
+        #endif
+        finalColor += color3.rgb * uFactor3;
+      }
+      if (uFactor4 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color4 = texture(uSampler4, vTextureCoord);
+        #else
+          vec4 color4 = texture2D(uSampler4, vTextureCoord);
+        #endif
+        finalColor += color4.rgb * uFactor4;
+      }
+      if (uFactor5 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color5 = texture(uSampler5, vTextureCoord);
+        #else
+          vec4 color5 = texture2D(uSampler5, vTextureCoord);
+        #endif
+        finalColor += color5.rgb * uFactor5;
+      }
+      if (uFactor6 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color6 = texture(uSampler6, vTextureCoord);
+        #else
+          vec4 color6 = texture2D(uSampler6, vTextureCoord);
+        #endif
+        finalColor += color6.rgb * uFactor6;
+      }
+      if (uFactor7 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color7 = texture(uSampler7, vTextureCoord);
+        #else
+          vec4 color7 = texture2D(uSampler7, vTextureCoord);
+        #endif
+        finalColor += color7.rgb * uFactor7;
+      }
+      fragColor = vec4(finalColor, 1.0);
+    }`;
+    }
+    static hipsEosbFS() {
+        return `#version 300 es
+    precision mediump float;
+
+    in vec2 vTextureCoord;
+
+    uniform sampler2D uSampler0;
+    uniform sampler2D uSampler1;
+    uniform sampler2D uSampler2;
+    uniform sampler2D uSampler3;
+    uniform sampler2D uSampler4;
+    uniform sampler2D uSampler5;
+    uniform sampler2D uSampler6;
+    uniform sampler2D uSampler7;
+
+    uniform float uFactor0;
+    uniform float uFactor1;
+    uniform float uFactor2;
+    uniform float uFactor3;
+    uniform float uFactor4;
+    uniform float uFactor5;
+    uniform float uFactor6;
+    uniform float uFactor7;
+
+    uniform int cmapIdx;
+    uniform float uSphericalGrid;
+
+    out vec4 fragColor;
+
+    struct colormap { float r[256]; float g[256]; float b[256]; } eosb;
+
+    colormap eosbCMap() {
+      eosb.r = float[256](/* full table unchanged */);
+      eosb.g = float[256](/* full table unchanged */);
+      eosb.b = float[256](/* full table unchanged */);
+      return eosb;
+    }
+
+    void main() {
+      vec3 finalColor = vec3(0.0);
+
+      if (uFactor0 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color0 = texture(uSampler0, vTextureCoord);
+        #else
+          vec4 color0 = texture2D(uSampler0, vTextureCoord);
+        #endif
+        colormap t = eosbCMap();
+        int x = int(floor(color0.r * 256.0));
+        int y = int(floor(color0.g * 256.0));
+        int z = int(floor(color0.b * 256.0));
+        vec3 mapped = vec3(t.r[x], t.g[y], t.b[z]) / 256.0;
+        finalColor += mapped * uFactor0;
+      }
+      if (uFactor1 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color1 = texture(uSampler1, vTextureCoord);
+        #else
+          vec4 color1 = texture2D(uSampler1, vTextureCoord);
+        #endif
+        finalColor += color1.rgb * uFactor1;
+      }
+      if (uFactor2 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color2 = texture(uSampler2, vTextureCoord);
+        #else
+          vec4 color2 = texture2D(uSampler2, vTextureCoord);
+        #endif
+        finalColor += color2.rgb * uFactor2;
+      }
+      if (uFactor3 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color3 = texture(uSampler3, vTextureCoord);
+        #else
+          vec4 color3 = texture2D(uSampler3, vTextureCoord);
+        #endif
+        finalColor += color3.rgb * uFactor3;
+      }
+      if (uFactor4 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color4 = texture(uSampler4, vTextureCoord);
+        #else
+          vec4 color4 = texture2D(uSampler4, vTextureCoord);
+        #endif
+        finalColor += color4.rgb * uFactor4;
+      }
+      if (uFactor5 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color5 = texture(uSampler5, vTextureCoord);
+        #else
+          vec4 color5 = texture2D(uSampler5, vTextureCoord);
+        #endif
+        finalColor += color5.rgb * uFactor5;
+      }
+      if (uFactor6 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color6 = texture(uSampler6, vTextureCoord);
+        #else
+          vec4 color6 = texture2D(uSampler6, vTextureCoord);
+        #endif
+        finalColor += color6.rgb * uFactor6;
+      }
+      if (uFactor7 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color7 = texture(uSampler7, vTextureCoord);
+        #else
+          vec4 color7 = texture2D(uSampler7, vTextureCoord);
+        #endif
+        finalColor += color7.rgb * uFactor7;
+      }
+      fragColor = vec4(finalColor, 1.0);
+    }`;
+    }
+    static hipsCubehelixFS() {
+        return `#version 300 es
+    precision mediump float;
+
+    in vec2 vTextureCoord;
+
+    uniform sampler2D uSampler0;
+    uniform sampler2D uSampler1;
+    uniform sampler2D uSampler2;
+    uniform sampler2D uSampler3;
+    uniform sampler2D uSampler4;
+    uniform sampler2D uSampler5;
+    uniform sampler2D uSampler6;
+    uniform sampler2D uSampler7;
+
+    uniform float uFactor0;
+    uniform float uFactor1;
+    uniform float uFactor2;
+    uniform float uFactor3;
+    uniform float uFactor4;
+    uniform float uFactor5;
+    uniform float uFactor6;
+    uniform float uFactor7;
+
+    uniform int cmapIdx;
+    uniform float uSphericalGrid;
+
+    out vec4 fragColor;
+
+    struct colormap { float r[256]; float g[256]; float b[256]; } cubehelix;
+
+    colormap cubehelixCMap() {
+      cubehelix.r = float[256](/* full table unchanged */);
+      cubehelix.g = float[256](/* full table unchanged */);
+      cubehelix.b = float[256](/* full table unchanged */);
+      return cubehelix;
+    }
+
+    void main() {
+      vec3 finalColor = vec3(0.0);
+
+      if (uFactor0 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color0 = texture(uSampler0, vTextureCoord);
+        #else
+          vec4 color0 = texture2D(uSampler0, vTextureCoord);
+        #endif
+        colormap t = cubehelixCMap();
+        int x = int(floor(color0.r * 256.0));
+        int y = int(floor(color0.g * 256.0));
+        int z = int(floor(color0.b * 256.0));
+        vec3 mapped = vec3(t.r[x], t.g[y], t.b[z]) / 256.0;
+        finalColor += mapped * uFactor0;
+      }
+      if (uFactor1 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color1 = texture(uSampler1, vTextureCoord);
+        #else
+          vec4 color1 = texture2D(uSampler1, vTextureCoord);
+        #endif
+        finalColor += color1.rgb * uFactor1;
+      }
+      if (uFactor2 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color2 = texture(uSampler2, vTextureCoord);
+        #else
+          vec4 color2 = texture2D(uSampler2, vTextureCoord);
+        #endif
+        finalColor += color2.rgb * uFactor2;
+      }
+      if (uFactor3 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color3 = texture(uSampler3, vTextureCoord);
+        #else
+          vec4 color3 = texture2D(uSampler3, vTextureCoord);
+        #endif
+        finalColor += color3.rgb * uFactor3;
+      }
+      if (uFactor4 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color4 = texture(uSampler4, vTextureCoord);
+        #else
+          vec4 color4 = texture2D(uSampler4, vTextureCoord);
+        #endif
+        finalColor += color4.rgb * uFactor4;
+      }
+      if (uFactor5 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color5 = texture(uSampler5, vTextureCoord);
+        #else
+          vec4 color5 = texture2D(uSampler5, vTextureCoord);
+        #endif
+        finalColor += color5.rgb * uFactor5;
+      }
+      if (uFactor6 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color6 = texture(uSampler6, vTextureCoord);
+        #else
+          vec4 color6 = texture2D(uSampler6, vTextureCoord);
+        #endif
+        finalColor += color6.rgb * uFactor6;
+      }
+      if (uFactor7 >= 0.0){
+        #if __VERSION__ > 120
+          vec4 color7 = texture(uSampler7, vTextureCoord);
+        #else
+          vec4 color7 = texture2D(uSampler7, vTextureCoord);
+        #endif
+        finalColor += color7.rgb * uFactor7;
+      }
+      fragColor = vec4(finalColor, 1.0);
+    }`;
+    }
+}
+//# sourceMappingURL=ShaderManagerMutliHiPS.js.map