@mapcatch/util 2.0.4 → 2.0.5-b

package/src/gl-operations/shaders/util/computeColor.glsl

@@ -1,85 +1,85 @@
-#pragma glslify: isCloseEnough = require(./isCloseEnough.glsl)
-#pragma glslify: getTexelValue = require(./getTexelValue.glsl)
-
-#ifndef DEFAULT_COLOR
-#define DEFAULT_COLOR vec4(0.0)
-#endif
-
-#ifndef SCALE_MAX_LENGTH
-#define SCALE_MAX_LENGTH 16
-#endif
-
-#ifndef SENTINEL_MAX_LENGTH
-#define SENTINEL_MAX_LENGTH 16
-#endif
-
-vec4 computeColor(
-  float inputVal,
-  sampler2D scaleColormap,
-  sampler2D sentinelColormap,
-  int scaleLength,
-  int sentinelLength,
-  bool littleEndian,
-  vec4 aboveColor,
-  vec4 belowColor
-) {
-
-  // vertical texture coordinate to find color and offset
-  float colorRow = 0.25;
-  float offsetRow = 0.75;
-
-  // Compare the value against any sentinel values, if defined.
-  if (sentinelLength > 0) {
-    for (int i = 0; i < SENTINEL_MAX_LENGTH; ++i) {
-      if (i == sentinelLength) {
-        break;
-      }
-
-      float i_f = float(i);
-      float sentinelLengthFloat = float(sentinelLength);
-      // retrieve the offset from the colormap
-      float sentinelOffset = getTexelValue(sentinelColormap, vec2((i_f + 0.5) / sentinelLengthFloat, offsetRow), littleEndian);
-      if (isCloseEnough(inputVal, sentinelOffset)) {
-        // retrieve the color from the colormap
-        vec2 colormapCoord = vec2((i_f + 0.5) / sentinelLengthFloat, colorRow);
-        return texture2D(sentinelColormap, colormapCoord);
-      }
-    }
-  }
-  // Do linear interpolation using the color scale, if defined.
-  if (scaleLength > 0) {
-    // If value below color scale range, clamp to lowest color stop.
-    float scaleOffsetLowest = getTexelValue(scaleColormap, vec2(0.0, offsetRow), littleEndian);
-    float scaleOffsetHighest = getTexelValue(scaleColormap, vec2(1.0, offsetRow), littleEndian);
-    if (inputVal < scaleOffsetLowest) {
-      return belowColor;
-    } else if (inputVal > scaleOffsetHighest) {
-      return aboveColor;
-    } else {
-      for (int i = 0; i < SCALE_MAX_LENGTH; ++i) {
-        float i_f = float(i);
-        float scaleLengthFloat = float(scaleLength);
-
-        // If value above color scale range, clamp to highest color stop.
-        if (i == scaleLength) {
-          return texture2D(sentinelColormap, vec2((scaleLengthFloat - 0.5) / scaleLengthFloat, colorRow));
-        }
-
-        float scaleOffsetNext = getTexelValue(scaleColormap, vec2((i_f + 1.0 + 0.5) / scaleLengthFloat, offsetRow), littleEndian);
-
-        if (inputVal <= scaleOffsetNext) {
-          float scaleOffset = getTexelValue(scaleColormap, vec2((i_f + 0.5) / scaleLengthFloat, offsetRow), littleEndian);
-          float percent = (inputVal - scaleOffset)
-            / (scaleOffsetNext - scaleOffset);
-          vec4 colorLow = texture2D(scaleColormap, vec2((i_f + 0.5) / scaleLengthFloat, colorRow));
-          vec4 colorHigh = texture2D(scaleColormap, vec2((i_f + 1.0 + 0.5) / scaleLengthFloat, colorRow));
-          return mix(colorLow, colorHigh, percent);
-        }
-      }
-    }
-  }
-
-  return DEFAULT_COLOR;
-}
-
-#pragma glslify: export(computeColor)
+#pragma glslify: isCloseEnough = require(./isCloseEnough.glsl)
+#pragma glslify: getTexelValue = require(./getTexelValue.glsl)
+
+#ifndef DEFAULT_COLOR
+#define DEFAULT_COLOR vec4(0.0)
+#endif
+
+#ifndef SCALE_MAX_LENGTH
+#define SCALE_MAX_LENGTH 16
+#endif
+
+#ifndef SENTINEL_MAX_LENGTH
+#define SENTINEL_MAX_LENGTH 16
+#endif
+
+vec4 computeColor(
+  float inputVal,
+  sampler2D scaleColormap,
+  sampler2D sentinelColormap,
+  int scaleLength,
+  int sentinelLength,
+  bool littleEndian,
+  vec4 aboveColor,
+  vec4 belowColor
+) {
+
+  // vertical texture coordinate to find color and offset
+  float colorRow = 0.25;
+  float offsetRow = 0.75;
+
+  // Compare the value against any sentinel values, if defined.
+  if (sentinelLength > 0) {
+    for (int i = 0; i < SENTINEL_MAX_LENGTH; ++i) {
+      if (i == sentinelLength) {
+        break;
+      }
+
+      float i_f = float(i);
+      float sentinelLengthFloat = float(sentinelLength);
+      // retrieve the offset from the colormap
+      float sentinelOffset = getTexelValue(sentinelColormap, vec2((i_f + 0.5) / sentinelLengthFloat, offsetRow), littleEndian);
+      if (isCloseEnough(inputVal, sentinelOffset)) {
+        // retrieve the color from the colormap
+        vec2 colormapCoord = vec2((i_f + 0.5) / sentinelLengthFloat, colorRow);
+        return texture2D(sentinelColormap, colormapCoord);
+      }
+    }
+  }
+  // Do linear interpolation using the color scale, if defined.
+  if (scaleLength > 0) {
+    // If value below color scale range, clamp to lowest color stop.
+    float scaleOffsetLowest = getTexelValue(scaleColormap, vec2(0.0, offsetRow), littleEndian);
+    float scaleOffsetHighest = getTexelValue(scaleColormap, vec2(1.0, offsetRow), littleEndian);
+    if (inputVal < scaleOffsetLowest) {
+      return belowColor;
+    } else if (inputVal > scaleOffsetHighest) {
+      return aboveColor;
+    } else {
+      for (int i = 0; i < SCALE_MAX_LENGTH; ++i) {
+        float i_f = float(i);
+        float scaleLengthFloat = float(scaleLength);
+
+        // If value above color scale range, clamp to highest color stop.
+        if (i == scaleLength) {
+          return texture2D(sentinelColormap, vec2((scaleLengthFloat - 0.5) / scaleLengthFloat, colorRow));
+        }
+
+        float scaleOffsetNext = getTexelValue(scaleColormap, vec2((i_f + 1.0 + 0.5) / scaleLengthFloat, offsetRow), littleEndian);
+
+        if (inputVal <= scaleOffsetNext) {
+          float scaleOffset = getTexelValue(scaleColormap, vec2((i_f + 0.5) / scaleLengthFloat, offsetRow), littleEndian);
+          float percent = (inputVal - scaleOffset)
+            / (scaleOffsetNext - scaleOffset);
+          vec4 colorLow = texture2D(scaleColormap, vec2((i_f + 0.5) / scaleLengthFloat, colorRow));
+          vec4 colorHigh = texture2D(scaleColormap, vec2((i_f + 1.0 + 0.5) / scaleLengthFloat, colorRow));
+          return mix(colorLow, colorHigh, percent);
+        }
+      }
+    }
+  }
+
+  return DEFAULT_COLOR;
+}
+
+#pragma glslify: export(computeColor)

package/src/gl-operations/shaders/util/getTexelValue.glsl

@@ -1,10 +1,10 @@
-// #pragma glslify: rgbaToFloat = require(glsl-rgba-to-float)
-#pragma glslify: rgbaToFloat = require(./rgbaToFloat.glsl)
-
-float getTexelValue(sampler2D texture, vec2 pos, bool littleEndian) {
-  vec4 texelRgba = texture2D(texture, pos);
-  float texelFloat = rgbaToFloat(texelRgba, littleEndian);
-  return texelFloat;
-}
-
-#pragma glslify: export(getTexelValue)
+// #pragma glslify: rgbaToFloat = require(glsl-rgba-to-float)
+#pragma glslify: rgbaToFloat = require(./rgbaToFloat.glsl)
+
+float getTexelValue(sampler2D texture, vec2 pos, bool littleEndian) {
+  vec4 texelRgba = texture2D(texture, pos);
+  float texelFloat = rgbaToFloat(texelRgba, littleEndian);
+  return texelFloat;
+}
+
+#pragma glslify: export(getTexelValue)

package/src/gl-operations/shaders/util/isCloseEnough.glsl

@@ -1,9 +1,9 @@
-#ifndef RELATIVE_TOLERANCE
-#define RELATIVE_TOLERANCE 0.0001
-#endif
-
-bool isCloseEnough(float a, float b) {
-  return abs(a - b) <= max(abs(a), abs(b)) * RELATIVE_TOLERANCE;
-}
-
-#pragma glslify: export(isCloseEnough)
+#ifndef RELATIVE_TOLERANCE
+#define RELATIVE_TOLERANCE 0.0001
+#endif
+
+bool isCloseEnough(float a, float b) {
+  return abs(a - b) <= max(abs(a), abs(b)) * RELATIVE_TOLERANCE;
+}
+
+#pragma glslify: export(isCloseEnough)

package/src/gl-operations/shaders/util/rgbaToFloat.glsl

@@ -1,18 +1,18 @@
-// From https://stackoverflow.com/questions/63827836/is-it-possible-to-do-a-rgba-to-float-and-back-round-trip-and-read-the-pixels-in
-
-// note: the 0.1s here and there are voodoo related to precision
-float rgbaToFloat(vec4 v, bool littleEndian) {
-  if (!littleEndian) {
-    v = v.abgr;
-  }
-  vec4 bits = v * 255.0;
-  float sign = mix(-1.0, 1.0, step(bits[3], 128.0));
-  float expo = floor(mod(bits[3] + 0.1, 128.0)) * 2.0 +
-        floor((bits[2] + 0.1) / 128.0) - 127.0;
-  float sig = bits[0] +
-        bits[1] * 256.0 +
-        floor(mod(bits[2] + 0.1, 128.0)) * 256.0 * 256.0;
-  return sign * (1.0 + sig / 8388607.0) * pow(2.0, expo);
-}
-
+// From https://stackoverflow.com/questions/63827836/is-it-possible-to-do-a-rgba-to-float-and-back-round-trip-and-read-the-pixels-in
+
+// note: the 0.1s here and there are voodoo related to precision
+float rgbaToFloat(vec4 v, bool littleEndian) {
+  if (!littleEndian) {
+    v = v.abgr;
+  }
+  vec4 bits = v * 255.0;
+  float sign = mix(-1.0, 1.0, step(bits[3], 128.0));
+  float expo = floor(mod(bits[3] + 0.1, 128.0)) * 2.0 +
+        floor((bits[2] + 0.1) / 128.0) - 127.0;
+  float sig = bits[0] +
+        bits[1] * 256.0 +
+        floor(mod(bits[2] + 0.1, 128.0)) * 256.0 * 256.0;
+  return sign * (1.0 + sig / 8388607.0) * pow(2.0, expo);
+}
+
 #pragma glslify: export(rgbaToFloat)

package/src/gl-operations/shaders/vertex/double.js

@@ -1,17 +1,17 @@
-import glsl from 'glslify'
-
-export default glsl`uniform mat4 transformMatrix;
-
-attribute vec2 position;
-attribute vec2 texCoordA;
-attribute vec2 texCoordB;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-
-void main() {
-  vTexCoordA = texCoordA;
-  vTexCoordB = texCoordB;
-  gl_Position = transformMatrix * vec4(position, 0.0, 1.0);
-}
+import glsl from 'glslify'
+
+export default glsl`uniform mat4 transformMatrix;
+
+attribute vec2 position;
+attribute vec2 texCoordA;
+attribute vec2 texCoordB;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+
+void main() {
+  vTexCoordA = texCoordA;
+  vTexCoordB = texCoordB;
+  gl_Position = transformMatrix * vec4(position, 0.0, 1.0);
+}
 `

package/src/gl-operations/shaders/vertex/multi3.js

@@ -1,20 +1,20 @@
-import glsl from 'glslify'
-
-export default glsl`uniform mat4 transformMatrix;
-
-attribute vec2 position;
-attribute vec2 texCoordA;
-attribute vec2 texCoordB;
-attribute vec2 texCoordC;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-varying vec2 vTexCoordC;
-
-void main() {
-  vTexCoordA = texCoordA;
-  vTexCoordB = texCoordB;
-  vTexCoordC = texCoordC;
-  gl_Position = transformMatrix * vec4(position, 0.0, 1.0);
-}
+import glsl from 'glslify'
+
+export default glsl`uniform mat4 transformMatrix;
+
+attribute vec2 position;
+attribute vec2 texCoordA;
+attribute vec2 texCoordB;
+attribute vec2 texCoordC;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+varying vec2 vTexCoordC;
+
+void main() {
+  vTexCoordA = texCoordA;
+  vTexCoordB = texCoordB;
+  vTexCoordC = texCoordC;
+  gl_Position = transformMatrix * vec4(position, 0.0, 1.0);
+}
 `

package/src/gl-operations/shaders/vertex/multi4.js

@@ -1,23 +1,23 @@
-import glsl from 'glslify'
-
-export default glsl`uniform mat4 transformMatrix;
-
-attribute vec2 position;
-attribute vec2 texCoordA;
-attribute vec2 texCoordB;
-attribute vec2 texCoordC;
-attribute vec2 texCoordD;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-varying vec2 vTexCoordC;
-varying vec2 vTexCoordD;
-
-void main() {
-  vTexCoordA = texCoordA;
-  vTexCoordB = texCoordB;
-  vTexCoordC = texCoordC;
-  vTexCoordD = texCoordD;
-  gl_Position = transformMatrix * vec4(position, 0.0, 1.0);
-}
+import glsl from 'glslify'
+
+export default glsl`uniform mat4 transformMatrix;
+
+attribute vec2 position;
+attribute vec2 texCoordA;
+attribute vec2 texCoordB;
+attribute vec2 texCoordC;
+attribute vec2 texCoordD;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+varying vec2 vTexCoordC;
+varying vec2 vTexCoordD;
+
+void main() {
+  vTexCoordA = texCoordA;
+  vTexCoordB = texCoordB;
+  vTexCoordC = texCoordC;
+  vTexCoordD = texCoordD;
+  gl_Position = transformMatrix * vec4(position, 0.0, 1.0);
+}
 `

package/src/gl-operations/shaders/vertex/multi5.js

@@ -1,26 +1,26 @@
-import glsl from 'glslify'
-
-export default glsl`uniform mat4 transformMatrix;
-
-attribute vec2 position;
-attribute vec2 texCoordA;
-attribute vec2 texCoordB;
-attribute vec2 texCoordC;
-attribute vec2 texCoordD;
-attribute vec2 texCoordE;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-varying vec2 vTexCoordC;
-varying vec2 vTexCoordD;
-varying vec2 vTexCoordE;
-
-void main() {
-  vTexCoordA = texCoordA;
-  vTexCoordB = texCoordB;
-  vTexCoordC = texCoordC;
-  vTexCoordD = texCoordD;
-  vTexCoordE = texCoordE;
-  gl_Position = transformMatrix * vec4(position, 0.0, 1.0);
-}
+import glsl from 'glslify'
+
+export default glsl`uniform mat4 transformMatrix;
+
+attribute vec2 position;
+attribute vec2 texCoordA;
+attribute vec2 texCoordB;
+attribute vec2 texCoordC;
+attribute vec2 texCoordD;
+attribute vec2 texCoordE;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+varying vec2 vTexCoordC;
+varying vec2 vTexCoordD;
+varying vec2 vTexCoordE;
+
+void main() {
+  vTexCoordA = texCoordA;
+  vTexCoordB = texCoordB;
+  vTexCoordC = texCoordC;
+  vTexCoordD = texCoordD;
+  vTexCoordE = texCoordE;
+  gl_Position = transformMatrix * vec4(position, 0.0, 1.0);
+}
 `

package/src/gl-operations/shaders/vertex/multi6.js

@@ -1,29 +1,29 @@
-import glsl from 'glslify'
-
-export default glsl`uniform mat4 transformMatrix;
-
-attribute vec2 position;
-attribute vec2 texCoordA;
-attribute vec2 texCoordB;
-attribute vec2 texCoordC;
-attribute vec2 texCoordD;
-attribute vec2 texCoordE;
-attribute vec2 texCoordF;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-varying vec2 vTexCoordC;
-varying vec2 vTexCoordD;
-varying vec2 vTexCoordE;
-varying vec2 vTexCoordF;
-
-void main() {
-  vTexCoordA = texCoordA;
-  vTexCoordB = texCoordB;
-  vTexCoordC = texCoordC;
-  vTexCoordD = texCoordD;
-  vTexCoordE = texCoordE;
-  vTexCoordE = texCoordF;
-  gl_Position = transformMatrix * vec4(position, 0.0, 1.0);
-}
+import glsl from 'glslify'
+
+export default glsl`uniform mat4 transformMatrix;
+
+attribute vec2 position;
+attribute vec2 texCoordA;
+attribute vec2 texCoordB;
+attribute vec2 texCoordC;
+attribute vec2 texCoordD;
+attribute vec2 texCoordE;
+attribute vec2 texCoordF;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+varying vec2 vTexCoordC;
+varying vec2 vTexCoordD;
+varying vec2 vTexCoordE;
+varying vec2 vTexCoordF;
+
+void main() {
+  vTexCoordA = texCoordA;
+  vTexCoordB = texCoordB;
+  vTexCoordC = texCoordC;
+  vTexCoordD = texCoordD;
+  vTexCoordE = texCoordE;
+  vTexCoordE = texCoordF;
+  gl_Position = transformMatrix * vec4(position, 0.0, 1.0);
+}
 `

package/src/gl-operations/shaders/vertex/single.js

@@ -1,13 +1,13 @@
-import glsl from 'glslify'
-
-export default glsl`uniform mat4 transformMatrix;
-
-attribute vec2 position;
-attribute vec2 texCoord;
-
-varying vec2 vTexCoord;
-
-void main() {
-  vTexCoord = texCoord;
-  gl_Position = transformMatrix * vec4(position, 0.0, 1.0);
-}`
+import glsl from 'glslify'
+
+export default glsl`uniform mat4 transformMatrix;
+
+attribute vec2 position;
+attribute vec2 texCoord;
+
+varying vec2 vTexCoord;
+
+void main() {
+  vTexCoord = texCoord;
+  gl_Position = transformMatrix * vec4(position, 0.0, 1.0);
+}`

package/src/gl-operations/shaders/vertex/singleNotTransformed.js

@@ -1,12 +1,12 @@
-import glsl from 'glslify'
-
-export default glsl`attribute vec2 position;
-attribute vec2 texCoord;
-
-varying vec2 vTexCoord;
-
-void main() {
-  vTexCoord = texCoord;
-  gl_Position = vec4(position, 0.0, 1.0);
-}
+import glsl from 'glslify'
+
+export default glsl`attribute vec2 position;
+attribute vec2 texCoord;
+
+varying vec2 vTexCoord;
+
+void main() {
+  vTexCoord = texCoord;
+  gl_Position = vec4(position, 0.0, 1.0);
+}
 `