@mapcatch/util 2.0.3 → 2.0.5-a

package/src/gl-operations/shaders/fragment/hillshading/hsAdvSmooth.js

@@ -1,54 +1,54 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-#pragma glslify: isCloseEnough = require(../../util/isCloseEnough.glsl)
-
-uniform float nodataValue;
-uniform bool littleEndian;
-uniform sampler2D tInput;
-uniform float pixelScale;
-uniform int kernelSize;
-varying vec2 vTexCoord;
-
-uniform float textureSize;
-
-int kernelEnd = int(kernelSize/2);
-int kernelStart = kernelEnd * -1;
-
-float runConvKernel(vec2 pos, vec2 onePixel) {
-  float convKernelWeight = 0.0;
-  float sum = 0.0;
-
-  for (int i = -20; i < 20; i ++) {
-    if (i < kernelStart) continue;
-    if (i > kernelEnd) break;
-    for (int j = -20; j < 20; j ++) {
-      if (j < kernelStart) continue;
-      if (j > kernelEnd) break;
-      float texelValue = texture2D(tInput, pos + onePixel * vec2(i, j)).r;
-      if (!isCloseEnough(texelValue, nodataValue)) {
-        sum = sum + texelValue;
-        convKernelWeight = convKernelWeight + 1.0;
-      }
-    }
-  }
-  return (sum / convKernelWeight);
-}
-
-
-void main() {
-  float texelFloat = texture2D(tInput, vTexCoord).r;
-  if (isCloseEnough(texelFloat, nodataValue)) {
-    gl_FragColor = vec4(nodataValue);
-  } else {
-    vec2 onePixel = vec2(1.0, 1.0) / textureSize;
-    float texelFloatSmoothed = runConvKernel(vTexCoord, onePixel);
-    gl_FragColor = vec4(texelFloatSmoothed);
-  }
-}
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+#pragma glslify: isCloseEnough = require(../../util/isCloseEnough.glsl)
+
+uniform float nodataValue;
+uniform bool littleEndian;
+uniform sampler2D tInput;
+uniform float pixelScale;
+uniform int kernelSize;
+varying vec2 vTexCoord;
+
+uniform float textureSize;
+
+int kernelEnd = int(kernelSize/2);
+int kernelStart = kernelEnd * -1;
+
+float runConvKernel(vec2 pos, vec2 onePixel) {
+  float convKernelWeight = 0.0;
+  float sum = 0.0;
+
+  for (int i = -20; i < 20; i ++) {
+    if (i < kernelStart) continue;
+    if (i > kernelEnd) break;
+    for (int j = -20; j < 20; j ++) {
+      if (j < kernelStart) continue;
+      if (j > kernelEnd) break;
+      float texelValue = texture2D(tInput, pos + onePixel * vec2(i, j)).r;
+      if (!isCloseEnough(texelValue, nodataValue)) {
+        sum = sum + texelValue;
+        convKernelWeight = convKernelWeight + 1.0;
+      }
+    }
+  }
+  return (sum / convKernelWeight);
+}
+
+
+void main() {
+  float texelFloat = texture2D(tInput, vTexCoord).r;
+  if (isCloseEnough(texelFloat, nodataValue)) {
+    gl_FragColor = vec4(nodataValue);
+  } else {
+    vec2 onePixel = vec2(1.0, 1.0) / textureSize;
+    float texelFloatSmoothed = runConvKernel(vTexCoord, onePixel);
+    gl_FragColor = vec4(texelFloatSmoothed);
+  }
+}
 `

package/src/gl-operations/shaders/fragment/hillshading/hsAdvSoftShadows.js

@@ -1,81 +1,81 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-uniform sampler2D tInput;
-uniform sampler2D tNormal;
-uniform sampler2D tSrc;
-uniform vec3 sunDirection;
-uniform vec2 resolution;
-uniform float pixelScale;
-uniform float softIterations;
-varying vec2 vTexCoord;
-
-void main() {
-  vec2 ires = 1.0 / resolution;
-  vec3 src = texture2D(tSrc, gl_FragCoord.xy * ires).rgb;
-  vec4 e0 = texture2D(tInput, vTexCoord);
-  vec3 n0 = texture2D(tNormal, vTexCoord).rgb;
-
-  // get 2D ray direction
-  vec2 sr = normalize(sunDirection.xy);
-
-  // initialize pixel traversal algorithm
-  vec2 p0 = vTexCoord * resolution;
-  vec2 p = floor(p0); // pixel we are starting in
-  vec2 stp = sign(sr);
-
-  // how far we need to travel in our ray direction to intersect the next pixel
-  // in the x- and y- directions
-  vec2 tMax = step(0.0, sr) * (1.0 - fract(p0)) + (1.0 - step(0.0, sr)) * fract(p0);
-  tMax /= abs(sr);
-  // how far must we travel along our ray to cover the width and height of a pixel
-  vec2 tDelta = 1.0 / abs(sr);
-
-  // pixel traversal routine
-  for (int i = 0; i < 65536; i++) {
-    if (tMax.x < tMax.y) {
-      tMax.x += tDelta.x;
-      p.x += stp.x;
-    } else {
-      tMax.y += tDelta.y;
-      p.y += stp.y;
-    }
-
-    // normalized texture coordinate for the center of the current pixel
-    vec2 ptex = ires * (p + 0.5);
-
-    // If we left the tile: add some illumination to the pixel for this iteration and stop traversing
-    if (ptex.x < 0.0 || ptex.x > 1.0 || ptex.y < 0.0 || ptex.y > 1.0) {
-      // illumination of this single ray
-      vec3 illumination = vec3(1.0/softIterations) * clamp(dot(n0, sunDirection), 0.0, 1.0);
-      // add illumination of this ray to result of previous iteration
-      gl_FragColor = vec4(src + illumination, 1.0);
-      return;
-    }
-
-    // elevation/value at current pixel
-    vec4 e = texture2D(tInput, ptex);
-    // time we have traveled along the 2D ray
-    float time = distance(p + 0.5, p0);
-    // elevation along our original 3D ray at the current point
-    float z = e0.r + time * pixelScale * sunDirection.z;
-
-    // If we did not exit tile, have we hit the terrain?
-    if (e.r > z) {
-      // We hit terrain. Do not add illumination for this iteration
-      gl_FragColor = vec4(src, 1.0);
-      return;
-    }
-  }
-
-  // Should have hit terrain or left the tile by this point, so should never need this
-  // If we finish the loop somehow, let’s pretend it’s been illuminated
-  vec3 illumination = vec3(1.0/softIterations) * clamp(dot(n0, sunDirection), 0.0, 1.0);
-  gl_FragColor = vec4(src + illumination, 1.0);
-}
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+uniform sampler2D tInput;
+uniform sampler2D tNormal;
+uniform sampler2D tSrc;
+uniform vec3 sunDirection;
+uniform vec2 resolution;
+uniform float pixelScale;
+uniform float softIterations;
+varying vec2 vTexCoord;
+
+void main() {
+  vec2 ires = 1.0 / resolution;
+  vec3 src = texture2D(tSrc, gl_FragCoord.xy * ires).rgb;
+  vec4 e0 = texture2D(tInput, vTexCoord);
+  vec3 n0 = texture2D(tNormal, vTexCoord).rgb;
+
+  // get 2D ray direction
+  vec2 sr = normalize(sunDirection.xy);
+
+  // initialize pixel traversal algorithm
+  vec2 p0 = vTexCoord * resolution;
+  vec2 p = floor(p0); // pixel we are starting in
+  vec2 stp = sign(sr);
+
+  // how far we need to travel in our ray direction to intersect the next pixel
+  // in the x- and y- directions
+  vec2 tMax = step(0.0, sr) * (1.0 - fract(p0)) + (1.0 - step(0.0, sr)) * fract(p0);
+  tMax /= abs(sr);
+  // how far must we travel along our ray to cover the width and height of a pixel
+  vec2 tDelta = 1.0 / abs(sr);
+
+  // pixel traversal routine
+  for (int i = 0; i < 65536; i++) {
+    if (tMax.x < tMax.y) {
+      tMax.x += tDelta.x;
+      p.x += stp.x;
+    } else {
+      tMax.y += tDelta.y;
+      p.y += stp.y;
+    }
+
+    // normalized texture coordinate for the center of the current pixel
+    vec2 ptex = ires * (p + 0.5);
+
+    // If we left the tile: add some illumination to the pixel for this iteration and stop traversing
+    if (ptex.x < 0.0 || ptex.x > 1.0 || ptex.y < 0.0 || ptex.y > 1.0) {
+      // illumination of this single ray
+      vec3 illumination = vec3(1.0/softIterations) * clamp(dot(n0, sunDirection), 0.0, 1.0);
+      // add illumination of this ray to result of previous iteration
+      gl_FragColor = vec4(src + illumination, 1.0);
+      return;
+    }
+
+    // elevation/value at current pixel
+    vec4 e = texture2D(tInput, ptex);
+    // time we have traveled along the 2D ray
+    float time = distance(p + 0.5, p0);
+    // elevation along our original 3D ray at the current point
+    float z = e0.r + time * pixelScale * sunDirection.z;
+
+    // If we did not exit tile, have we hit the terrain?
+    if (e.r > z) {
+      // We hit terrain. Do not add illumination for this iteration
+      gl_FragColor = vec4(src, 1.0);
+      return;
+    }
+  }
+
+  // Should have hit terrain or left the tile by this point, so should never need this
+  // If we finish the loop somehow, let’s pretend it’s been illuminated
+  vec3 illumination = vec3(1.0/softIterations) * clamp(dot(n0, sunDirection), 0.0, 1.0);
+  gl_FragColor = vec4(src + illumination, 1.0);
+}
 `

package/src/gl-operations/shaders/fragment/hillshading/hsPregen.js

@@ -1,50 +1,55 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-#pragma glslify: computeColor = require(../../util/computeColor.glsl)
-#pragma glslify: isCloseEnough = require(../../util/isCloseEnough.glsl)
-#pragma glslify: getTexelValue = require(../../util/getTexelValue.glsl)
-
-uniform int scaleLength;
-uniform int sentinelLength;
-uniform sampler2D scaleColormap;
-uniform sampler2D sentinelColormap;
-
-uniform float nodataValue;
-uniform sampler2D texture;
-uniform bool littleEndian;
-uniform sampler2D hillshadePregenTexture;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-
-void main() {
-  float texelFloat = getTexelValue(texture, vTexCoordA, littleEndian);
-
-  if (isCloseEnough(texelFloat, nodataValue)) {
-    discard;
-  }
-
-  vec4 clr = computeColor(
-    texelFloat,
-    scaleColormap,
-    sentinelColormap,
-    scaleLength,
-    sentinelLength,
-    littleEndian
-  );
-
-  // Hillshade
-  float light = texture2D(hillshadePregenTexture, vTexCoordB).r;
-  // float light = getTexelValue(vTexCoordB, hillshadePregenTexture, littleEndian).r;
-  clr.rgb = light * pow(clr.rgb, vec3(2.0));
-  clr.rgb = pow(clr.rgb, vec3(1.0/2.2));
-
-  gl_FragColor = clr;
-}
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+#pragma glslify: computeColor = require(../../util/computeColor.glsl)
+#pragma glslify: isCloseEnough = require(../../util/isCloseEnough.glsl)
+#pragma glslify: getTexelValue = require(../../util/getTexelValue.glsl)
+
+uniform int scaleLength;
+uniform int sentinelLength;
+uniform sampler2D scaleColormap;
+uniform sampler2D sentinelColormap;
+
+uniform vec4 aboveColor;
+uniform vec4 belowColor;
+
+uniform float nodataValue;
+uniform sampler2D texture;
+uniform bool littleEndian;
+uniform sampler2D hillshadePregenTexture;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+
+void main() {
+  float texelFloat = getTexelValue(texture, vTexCoordA, littleEndian);
+
+  if (isCloseEnough(texelFloat, nodataValue)) {
+    discard;
+  }
+
+  vec4 clr = computeColor(
+    texelFloat,
+    scaleColormap,
+    sentinelColormap,
+    scaleLength,
+    sentinelLength,
+    littleEndian,
+    aboveColor,
+    belowColor
+  );
+
+  // Hillshade
+  float light = texture2D(hillshadePregenTexture, vTexCoordB).r;
+  // float light = getTexelValue(vTexCoordB, hillshadePregenTexture, littleEndian).r;
+  clr.rgb = light * pow(clr.rgb, vec3(2.0));
+  clr.rgb = pow(clr.rgb, vec3(1.0/2.2));
+
+  gl_FragColor = clr;
+}
 `

package/src/gl-operations/shaders/fragment/interpolateColor.js

@@ -1,63 +1,66 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-#define TRANSPARENT vec4(0.0)
-
-#pragma glslify: computeColor = require(../util/computeColor.glsl)
-#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
-#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
-
-uniform sampler2D textureA;
-uniform sampler2D textureB;
-
-uniform int scaleLengthA;
-uniform int sentinelLengthA;
-uniform sampler2D scaleColormapA;
-uniform sampler2D sentinelColormapA;
-
-uniform int scaleLengthB;
-uniform int sentinelLengthB;
-uniform sampler2D scaleColormapB;
-uniform sampler2D sentinelColormapB;
-
-uniform float nodataValue;
-uniform bool littleEndian;
-uniform float interpolationFraction;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-
-void main() {
-  if (interpolationFraction <= 0.0) {
-    float texelFloat = getTexelValue(textureA, vTexCoordA, littleEndian);
-    if (isCloseEnough(texelFloat, nodataValue)) {
-      discard;
-    }
-    gl_FragColor = computeColor(texelFloat, scaleColormapA, sentinelColormapA, scaleLengthA, sentinelLengthA, littleEndian);
-  } else if (interpolationFraction >= 1.0) {
-    float texelFloat = getTexelValue(textureB, vTexCoordB, littleEndian);
-    if (isCloseEnough(texelFloat, nodataValue)) {
-      discard;
-    }
-    gl_FragColor = computeColor(texelFloat, scaleColormapB, sentinelColormapB, scaleLengthB, sentinelLengthB, littleEndian);
-  } else {
-    float texelFloatA = getTexelValue(textureA, vTexCoordA, littleEndian);
-    float texelFloatB = getTexelValue(textureB, vTexCoordB, littleEndian);
-    vec4 colorA = (
-      isCloseEnough(texelFloatA, nodataValue)
-      ? TRANSPARENT
-      : computeColor(texelFloatA, scaleColormapA, sentinelColormapA, scaleLengthA, sentinelLengthA, littleEndian)
-    );
-    vec4 colorB = (
-      isCloseEnough(texelFloatB, nodataValue)
-      ? TRANSPARENT
-      : computeColor(texelFloatB, scaleColormapB, sentinelColormapB, scaleLengthB, sentinelLengthB, littleEndian)
-    );
-    gl_FragColor = mix(colorA, colorB, interpolationFraction);
-  }
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+#define TRANSPARENT vec4(0.0)
+
+#pragma glslify: computeColor = require(../util/computeColor.glsl)
+#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
+#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
+
+uniform sampler2D textureA;
+uniform sampler2D textureB;
+
+uniform int scaleLengthA;
+uniform int sentinelLengthA;
+uniform sampler2D scaleColormapA;
+uniform sampler2D sentinelColormapA;
+
+uniform int scaleLengthB;
+uniform int sentinelLengthB;
+uniform sampler2D scaleColormapB;
+uniform sampler2D sentinelColormapB;
+
+uniform float nodataValue;
+uniform bool littleEndian;
+uniform float interpolationFraction;
+
+uniform vec4 aboveColor;
+uniform vec4 belowColor;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+
+void main() {
+  if (interpolationFraction <= 0.0) {
+    float texelFloat = getTexelValue(textureA, vTexCoordA, littleEndian);
+    if (isCloseEnough(texelFloat, nodataValue)) {
+      discard;
+    }
+    gl_FragColor = computeColor(texelFloat, scaleColormapA, sentinelColormapA, scaleLengthA, sentinelLengthA, littleEndian, aboveColor, belowColor);
+  } else if (interpolationFraction >= 1.0) {
+    float texelFloat = getTexelValue(textureB, vTexCoordB, littleEndian);
+    if (isCloseEnough(texelFloat, nodataValue)) {
+      discard;
+    }
+    gl_FragColor = computeColor(texelFloat, scaleColormapB, sentinelColormapB, scaleLengthB, sentinelLengthB, littleEndian, aboveColor, belowColor);
+  } else {
+    float texelFloatA = getTexelValue(textureA, vTexCoordA, littleEndian);
+    float texelFloatB = getTexelValue(textureB, vTexCoordB, littleEndian);
+    vec4 colorA = (
+      isCloseEnough(texelFloatA, nodataValue)
+      ? TRANSPARENT
+      : computeColor(texelFloatA, scaleColormapA, sentinelColormapA, scaleLengthA, sentinelLengthA, littleEndian, aboveColor, belowColor)
+    );
+    vec4 colorB = (
+      isCloseEnough(texelFloatB, nodataValue)
+      ? TRANSPARENT
+      : computeColor(texelFloatB, scaleColormapB, sentinelColormapB, scaleLengthB, sentinelLengthB, littleEndian, aboveColor, belowColor)
+    );
+    gl_FragColor = mix(colorA, colorB, interpolationFraction);
+  }
 }`

package/src/gl-operations/shaders/fragment/interpolateColorOnly.js

@@ -1,47 +1,50 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-#pragma glslify: computeColor = require(../util/computeColor.glsl)
-#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
-#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
-
-uniform sampler2D texture;
-
-uniform int scaleLengthA;
-uniform int sentinelLengthA;
-uniform sampler2D scaleColormapA;
-uniform sampler2D sentinelColormapA;
-
-uniform int scaleLengthB;
-uniform int sentinelLengthB;
-uniform sampler2D scaleColormapB;
-uniform sampler2D sentinelColormapB;
-
-uniform float nodataValue;
-uniform bool littleEndian;
-uniform float interpolationFraction;
-
-varying vec2 vTexCoord;
-
-void main() {
-  float texelFloat = getTexelValue(texture, vTexCoord, littleEndian);
-
-  if (isCloseEnough(texelFloat, nodataValue)) {
-    discard;
-  }
-
-  if (interpolationFraction <= 0.0) {
-    gl_FragColor = computeColor(texelFloat, scaleColormapA, sentinelColormapA, scaleLengthA, sentinelLengthA, littleEndian);
-  } else if (interpolationFraction >= 1.0) {
-    gl_FragColor = computeColor(texelFloat, scaleColormapB, sentinelColormapB, scaleLengthB, sentinelLengthB, littleEndian);
-  } else {
-    vec4 colorA = computeColor(texelFloat, scaleColormapA, sentinelColormapA, scaleLengthA, sentinelLengthA, littleEndian);
-    vec4 colorB = computeColor(texelFloat, scaleColormapB, sentinelColormapB, scaleLengthB, sentinelLengthB, littleEndian);
-    gl_FragColor = mix(colorA, colorB, interpolationFraction);
-  }
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+#pragma glslify: computeColor = require(../util/computeColor.glsl)
+#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
+#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
+
+uniform sampler2D texture;
+
+uniform int scaleLengthA;
+uniform int sentinelLengthA;
+uniform sampler2D scaleColormapA;
+uniform sampler2D sentinelColormapA;
+
+uniform int scaleLengthB;
+uniform int sentinelLengthB;
+uniform sampler2D scaleColormapB;
+uniform sampler2D sentinelColormapB;
+
+uniform float nodataValue;
+uniform bool littleEndian;
+uniform float interpolationFraction;
+
+uniform vec4 aboveColor;
+uniform vec4 belowColor;
+
+varying vec2 vTexCoord;
+
+void main() {
+  float texelFloat = getTexelValue(texture, vTexCoord, littleEndian);
+
+  if (isCloseEnough(texelFloat, nodataValue)) {
+    discard;
+  }
+
+  if (interpolationFraction <= 0.0) {
+    gl_FragColor = computeColor(texelFloat, scaleColormapA, sentinelColormapA, scaleLengthA, sentinelLengthA, littleEndian, aboveColor, belowColor);
+  } else if (interpolationFraction >= 1.0) {
+    gl_FragColor = computeColor(texelFloat, scaleColormapB, sentinelColormapB, scaleLengthB, sentinelLengthB, littleEndian, aboveColor, belowColor);
+  } else {
+    vec4 colorA = computeColor(texelFloat, scaleColormapA, sentinelColormapA, scaleLengthA, sentinelLengthA, littleEndian, aboveColor, belowColor);
+    vec4 colorB = computeColor(texelFloat, scaleColormapB, sentinelColormapB, scaleLengthB, sentinelLengthB, littleEndian, aboveColor, belowColor);
+    gl_FragColor = mix(colorA, colorB, interpolationFraction);
+  }
 }`