@mapcatch/util 2.0.4 → 2.0.5-a

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

@@ -1,47 +1,47 @@
-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 int scaleLength;
-uniform int sentinelLength;
-uniform sampler2D scaleColormap;
-uniform sampler2D sentinelColormap;
-
-uniform float nodataValue;
-uniform sampler2D texture;
-uniform bool littleEndian;
-
-uniform vec4 aboveColor;
-uniform vec4 belowColor;
-
-varying vec2 vTexCoord;
-
-void main() {
-  float f = getTexelValue(texture, vTexCoord, littleEndian);
-
-  if (isCloseEnough(f, nodataValue)) {
-    gl_FragColor = TRANSPARENT;
-  } else {
-    gl_FragColor = computeColor(
-      f,
-      scaleColormap,
-      sentinelColormap,
-      scaleLength,
-      sentinelLength,
-      littleEndian,
-      aboveColor,
-      belowColor
-    );
-  }
-}
+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 int scaleLength;
+uniform int sentinelLength;
+uniform sampler2D scaleColormap;
+uniform sampler2D sentinelColormap;
+
+uniform float nodataValue;
+uniform sampler2D texture;
+uniform bool littleEndian;
+
+uniform vec4 aboveColor;
+uniform vec4 belowColor;
+
+varying vec2 vTexCoord;
+
+void main() {
+  float f = getTexelValue(texture, vTexCoord, littleEndian);
+
+  if (isCloseEnough(f, nodataValue)) {
+    gl_FragColor = TRANSPARENT;
+  } else {
+    gl_FragColor = computeColor(
+      f,
+      scaleColormap,
+      sentinelColormap,
+      scaleLength,
+      sentinelLength,
+      littleEndian,
+      aboveColor,
+      belowColor
+    );
+  }
+}
 `

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

@@ -1,79 +1,79 @@
-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 direction;
-uniform vec2 resolution;
-uniform float pixelScale;
-uniform float ambientIterations;
-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;
-
-  vec3 sr3d = normalize(n0 + direction); // ray direction
-  vec2 sr = normalize(sr3d.xy); // get 2D ray direction
-
-  // 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/ambientIterations);
-      // 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 * sr3d.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/ambientIterations);
-  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 direction;
+uniform vec2 resolution;
+uniform float pixelScale;
+uniform float ambientIterations;
+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;
+
+  vec3 sr3d = normalize(n0 + direction); // ray direction
+  vec2 sr = normalize(sr3d.xy); // get 2D ray direction
+
+  // 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/ambientIterations);
+      // 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 * sr3d.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/ambientIterations);
+  gl_FragColor = vec4(src + illumination, 1.0);
 }`

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

@@ -1,60 +1,60 @@
-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)
-
-uniform sampler2D tInput;
-uniform sampler2D tNormal;
-uniform float floatScale;
-uniform vec3 sunDirection;
-uniform float nodataValue;
-uniform bool littleEndian;
-varying vec2 vTexCoord;
-
-uniform vec4 aboveColor;
-uniform vec4 belowColor;
-
-uniform int scaleLength;
-uniform int sentinelLength;
-uniform sampler2D scaleColormap;
-uniform sampler2D sentinelColormap;
-
-void main() {
-  float f = texture2D(tInput, vTexCoord).r;
-
-  if (isCloseEnough(f, nodataValue)) {
-    // discard;
-    gl_FragColor = vec4(0.0);
-  } else {
-    vec4 clr = computeColor(
-      f / floatScale,
-      scaleColormap,
-      sentinelColormap,
-      scaleLength,
-      sentinelLength,
-      littleEndian,
-      aboveColor,
-      belowColor
-    );
-
-    vec3 n = texture2D(tNormal, vTexCoord).rgb;
-
-    // light intensity that varies on the range  [−1..1]
-    float light = dot(n, sunDirection);
-    // transform the light intensity to the range [0..1]
-    light = 0.5 * light + 0.5;
-
-    // gl_FragColor = vec4(l, l, l, 1.0); // to show light
-
-    vec3 color = light * pow(clr.rgb, vec3(2.0));
-    color = pow(color, vec3(1.0/2.2));
-    gl_FragColor = vec4(color, 1.0);
-  }
-}
+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)
+
+uniform sampler2D tInput;
+uniform sampler2D tNormal;
+uniform float floatScale;
+uniform vec3 sunDirection;
+uniform float nodataValue;
+uniform bool littleEndian;
+varying vec2 vTexCoord;
+
+uniform vec4 aboveColor;
+uniform vec4 belowColor;
+
+uniform int scaleLength;
+uniform int sentinelLength;
+uniform sampler2D scaleColormap;
+uniform sampler2D sentinelColormap;
+
+void main() {
+  float f = texture2D(tInput, vTexCoord).r;
+
+  if (isCloseEnough(f, nodataValue)) {
+    // discard;
+    gl_FragColor = vec4(0.0);
+  } else {
+    vec4 clr = computeColor(
+      f / floatScale,
+      scaleColormap,
+      sentinelColormap,
+      scaleLength,
+      sentinelLength,
+      littleEndian,
+      aboveColor,
+      belowColor
+    );
+
+    vec3 n = texture2D(tNormal, vTexCoord).rgb;
+
+    // light intensity that varies on the range  [−1..1]
+    float light = dot(n, sunDirection);
+    // transform the light intensity to the range [0..1]
+    light = 0.5 * light + 0.5;
+
+    // gl_FragColor = vec4(l, l, l, 1.0); // to show light
+
+    vec3 color = light * pow(clr.rgb, vec3(2.0));
+    color = pow(color, vec3(1.0/2.2));
+    gl_FragColor = vec4(color, 1.0);
+  }
+}
 `

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

@@ -1,31 +1,31 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-uniform sampler2D tBase;
-uniform sampler2D tSoftShadow;
-uniform sampler2D tAmbient;
-uniform float finalSoftMultiplier;
-uniform float finalAmbientMultiplier;
-uniform float nodataValue;
-uniform bool littleEndian;
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-
-void main() {
-  vec3 baselayer = texture2D(tBase, vTexCoordA).rgb;
-
-  float softShadow = texture2D(tSoftShadow, vTexCoordB).r;
-  float ambient = texture2D(tAmbient, vTexCoordB).r;
-  // Add up the lighting
-  float light = finalSoftMultiplier * softShadow + finalAmbientMultiplier * ambient;
-  //Deepen the original color a bit by applying a curve, and multiply it by the light
-  vec3 color = light * pow(baselayer.rgb, vec3(2.0));
-  // apply gamma correction
-  color = pow(color, vec3(1.0/2.2));
-  gl_FragColor = vec4(color, 1.0);
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+uniform sampler2D tBase;
+uniform sampler2D tSoftShadow;
+uniform sampler2D tAmbient;
+uniform float finalSoftMultiplier;
+uniform float finalAmbientMultiplier;
+uniform float nodataValue;
+uniform bool littleEndian;
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+
+void main() {
+  vec3 baselayer = texture2D(tBase, vTexCoordA).rgb;
+
+  float softShadow = texture2D(tSoftShadow, vTexCoordB).r;
+  float ambient = texture2D(tAmbient, vTexCoordB).r;
+  // Add up the lighting
+  float light = finalSoftMultiplier * softShadow + finalAmbientMultiplier * ambient;
+  //Deepen the original color a bit by applying a curve, and multiply it by the light
+  vec3 color = light * pow(baselayer.rgb, vec3(2.0));
+  // apply gamma correction
+  color = pow(color, vec3(1.0/2.2));
+  gl_FragColor = vec4(color, 1.0);
 }`

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

@@ -1,61 +1,61 @@
-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)
-
-uniform sampler2D tInput;
-uniform sampler2D tSoftShadow;
-uniform sampler2D tAmbient;
-uniform float floatScale;
-uniform float finalSoftMultiplier;
-uniform float finalAmbientMultiplier;
-uniform float nodataValue;
-uniform bool littleEndian;
-uniform int scaleLength;
-uniform int sentinelLength;
-uniform sampler2D scaleColormap;
-uniform sampler2D sentinelColormap;
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-
-uniform vec4 aboveColor;
-uniform vec4 belowColor;
-
-void main() {
-  float f = texture2D(tInput, vTexCoordA).r;
-
-  if (isCloseEnough(f, nodataValue)) {
-    gl_FragColor = vec4(0.0);
-    return;
-  } else {
-    vec4 clr = computeColor(
-      f / floatScale,
-      scaleColormap,
-      sentinelColormap,
-      scaleLength,
-      sentinelLength,
-      littleEndian,
-      aboveColor,
-      belowColor
-    );
-
-    float softShadow = texture2D(tSoftShadow, vTexCoordB).r;
-    float ambient = texture2D(tAmbient, vTexCoordB).r;
-    // Add up the lighting
-    float light = finalSoftMultiplier * softShadow + finalAmbientMultiplier * ambient;
-    // Deepen the original color a bit by applying a curve, and multiply it by the light
-    vec3 color = light * pow(clr.rgb, vec3(2.0));
-    // apply gamma correction
-    color = pow(color, vec3(1.0/2.2));
-    gl_FragColor = vec4(color, 1.0);
-    // gl_FragColor = vec4(clr.rgb, 1.0);
-  }
-  // vec3 n = texture2D(tInput, vTexCoordA).rgb;
-  // gl_FragColor = vec4((0.5 * n + 0.5)*0.1, 1.0);
+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)
+
+uniform sampler2D tInput;
+uniform sampler2D tSoftShadow;
+uniform sampler2D tAmbient;
+uniform float floatScale;
+uniform float finalSoftMultiplier;
+uniform float finalAmbientMultiplier;
+uniform float nodataValue;
+uniform bool littleEndian;
+uniform int scaleLength;
+uniform int sentinelLength;
+uniform sampler2D scaleColormap;
+uniform sampler2D sentinelColormap;
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+
+uniform vec4 aboveColor;
+uniform vec4 belowColor;
+
+void main() {
+  float f = texture2D(tInput, vTexCoordA).r;
+
+  if (isCloseEnough(f, nodataValue)) {
+    gl_FragColor = vec4(0.0);
+    return;
+  } else {
+    vec4 clr = computeColor(
+      f / floatScale,
+      scaleColormap,
+      sentinelColormap,
+      scaleLength,
+      sentinelLength,
+      littleEndian,
+      aboveColor,
+      belowColor
+    );
+
+    float softShadow = texture2D(tSoftShadow, vTexCoordB).r;
+    float ambient = texture2D(tAmbient, vTexCoordB).r;
+    // Add up the lighting
+    float light = finalSoftMultiplier * softShadow + finalAmbientMultiplier * ambient;
+    // Deepen the original color a bit by applying a curve, and multiply it by the light
+    vec3 color = light * pow(clr.rgb, vec3(2.0));
+    // apply gamma correction
+    color = pow(color, vec3(1.0/2.2));
+    gl_FragColor = vec4(color, 1.0);
+    // gl_FragColor = vec4(clr.rgb, 1.0);
+  }
+  // vec3 n = texture2D(tInput, vTexCoordA).rgb;
+  // gl_FragColor = vec4((0.5 * n + 0.5)*0.1, 1.0);
 }`

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

@@ -1,27 +1,27 @@
-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)
-#pragma glslify: getTexelValue = require(../../util/getTexelValue.glsl)
-
-uniform float nodataValue;
-uniform bool littleEndian;
-uniform sampler2D texture;
-uniform float floatScale;
-varying vec2 vTexCoord;
-
-void main() {
-  float f = getTexelValue(texture, vTexCoord, littleEndian);
-
-  if (isCloseEnough(f, nodataValue)) {
-    gl_FragColor = vec4(nodataValue);
-  } else {
-    // Scale the input value and write to framebuffer
-    gl_FragColor = vec4(f * floatScale);
-  }
+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)
+#pragma glslify: getTexelValue = require(../../util/getTexelValue.glsl)
+
+uniform float nodataValue;
+uniform bool littleEndian;
+uniform sampler2D texture;
+uniform float floatScale;
+varying vec2 vTexCoord;
+
+void main() {
+  float f = getTexelValue(texture, vTexCoord, littleEndian);
+
+  if (isCloseEnough(f, nodataValue)) {
+    gl_FragColor = vec4(nodataValue);
+  } else {
+    // Scale the input value and write to framebuffer
+    gl_FragColor = vec4(f * floatScale);
+  }
 }`

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

@@ -1,26 +1,26 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-uniform float nodataValue;
-uniform bool littleEndian;
-uniform sampler2D tInput;
-uniform float pixelScale;
-uniform float onePixel;
-varying vec2 vTexCoord;
-
-void main() {
-  float p0 = texture2D(tInput, vTexCoord).r;
-  float px = texture2D(tInput, vec2(vTexCoord.x + onePixel, vTexCoord.y)).r;
-  float py = texture2D(tInput, vec2(vTexCoord.x, vTexCoord.y  + onePixel)).r;
-  vec3 dx = vec3(pixelScale, 0.0, px - p0);
-  vec3 dy = vec3(0.0, pixelScale, py - p0);
-  vec3 n = normalize(cross(dx, dy));
-
-  gl_FragColor = vec4(n, 1.0);
-  // gl_FragColor = vec4(0.5 * n + 0.5, 1.0); // to show
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+uniform float nodataValue;
+uniform bool littleEndian;
+uniform sampler2D tInput;
+uniform float pixelScale;
+uniform float onePixel;
+varying vec2 vTexCoord;
+
+void main() {
+  float p0 = texture2D(tInput, vTexCoord).r;
+  float px = texture2D(tInput, vec2(vTexCoord.x + onePixel, vTexCoord.y)).r;
+  float py = texture2D(tInput, vec2(vTexCoord.x, vTexCoord.y  + onePixel)).r;
+  vec3 dx = vec3(pixelScale, 0.0, px - p0);
+  vec3 dy = vec3(0.0, pixelScale, py - p0);
+  vec3 n = normalize(cross(dx, dy));
+
+  gl_FragColor = vec4(n, 1.0);
+  // gl_FragColor = vec4(0.5 * n + 0.5, 1.0); // to show
 }`