@mapcatch/util 2.0.6 → 2.0.8

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

@@ -1,31 +0,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 +0,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 +0,0 @@
-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 +0,0 @@
-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
-}`

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

@@ -1,54 +0,0 @@
-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 +0,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,55 +0,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)
-#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,66 +0,0 @@
-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,50 +0,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)
-#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);
-  }
-}`

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

@@ -1,137 +0,0 @@
-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 textureA;
-uniform sampler2D textureB;
-uniform bool littleEndian;
-uniform float interpolationFraction;
-
-uniform vec4 aboveColor;
-uniform vec4 belowColor;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-
-bool isSentinelValue(sampler2D sentinelColormap, int len, float value) {
-  for (int i = 0; i < SENTINEL_MAX_LENGTH; ++i) {
-    if (i == len) {
-      break;
-    }
-    float i_f = float(i);
-    float lenFloat = float(len);
-    float sentinelOffset = getTexelValue(sentinelColormap, vec2((i_f + 0.5) / lenFloat, 0.75), littleEndian);
-    if (isCloseEnough(sentinelOffset, value)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-void main() {
-  if (interpolationFraction <= 0.0) {
-    float texelFloat = getTexelValue(textureA, vTexCoordA, littleEndian);
-    if (isCloseEnough(texelFloat, nodataValue)) {
-      discard;
-    }
-    gl_FragColor = computeColor(
-      texelFloat,
-      scaleColormap,
-      sentinelColormap,
-      scaleLength,
-      sentinelLength,
-      littleEndian,
-      aboveColor,
-      belowColor
-    );
-  } else if (interpolationFraction >= 1.0) {
-    float texelFloat = getTexelValue(textureB, vTexCoordB, littleEndian);
-    if (isCloseEnough(texelFloat, nodataValue)) {
-      discard;
-    }
-    gl_FragColor = computeColor(
-      texelFloat,
-      scaleColormap,
-      sentinelColormap,
-      scaleLength,
-      sentinelLength,
-      littleEndian,
-      aboveColor,
-      belowColor
-    );
-  } else {
-    // retrieve and decode pixel value from both tiles
-    float texelFloatA = getTexelValue(textureA, vTexCoordA, littleEndian);
-    float texelFloatB = getTexelValue(textureB, vTexCoordB, littleEndian);
-    bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
-    bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
-    if (aIsNodata && bIsNodata) {
-      discard;
-    } else if (
-      aIsNodata
-      || bIsNodata
-      || scaleLength == 0
-      || isSentinelValue(sentinelColormap, sentinelLength, texelFloatA)
-      || isSentinelValue(sentinelColormap, sentinelLength, texelFloatB)
-    ) {
-      vec4 colorA = (
-        aIsNodata
-        ? TRANSPARENT
-        : computeColor(
-            texelFloatA,
-            scaleColormap,
-            sentinelColormap,
-            scaleLength,
-            sentinelLength,
-            littleEndian,
-            aboveColor,
-            belowColor
-          )
-      );
-      vec4 colorB = (
-        bIsNodata
-        ? TRANSPARENT
-        : computeColor(
-            texelFloatB,
-            scaleColormap,
-            sentinelColormap,
-            scaleLength,
-            sentinelLength,
-            littleEndian,
-            aboveColor,
-            belowColor
-          )
-      );
-      gl_FragColor = mix(colorA, colorB, interpolationFraction);
-    } else {
-      float interpolated = mix(texelFloatA, texelFloatB, interpolationFraction);
-      gl_FragColor = computeColor(
-        interpolated,
-        scaleColormap,
-        sentinelColormap,
-        scaleLength,
-        sentinelLength,
-        littleEndian,
-        aboveColor,
-        belowColor
-      );
-    }
-  }
-}
-`

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

@@ -1,36 +0,0 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
-#pragma glslify: floatToRgba = require(glsl-float-to-rgba)
-#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
-
-uniform sampler2D textureA;
-
-uniform float nodataValue;
-uniform bool littleEndian;
-
-uniform float filterLowA;
-uniform float filterHighA;
-uniform float multiplierA;
-
-varying vec2 vTexCoord;
-
-void main() {
-  float texelFloatA = getTexelValue(textureA, vTexCoord, littleEndian);
-
-  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
-
-  if (aIsNodata || texelFloatA < filterLowA || texelFloatA > filterHighA) {
-    gl_FragColor = floatToRgba(nodataValue, littleEndian);
-  } else {
-    float texelFloatFinal = texelFloatA * multiplierA;
-    gl_FragColor = floatToRgba(texelFloatFinal, littleEndian);
-  }
-}
-`

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

@@ -1,46 +0,0 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
-#pragma glslify: floatToRgba = require(glsl-float-to-rgba)
-#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
-
-uniform sampler2D textureA;
-uniform sampler2D textureB;
-
-uniform float nodataValue;
-uniform bool littleEndian;
-
-uniform float filterLowA;
-uniform float filterHighA;
-uniform float filterLowB;
-uniform float filterHighB;
-uniform float multiplierA;
-uniform float multiplierB;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-
-void main() {
-  float texelFloatA = getTexelValue(textureA, vTexCoordA, littleEndian);
-  float texelFloatB = getTexelValue(textureB, vTexCoordB, littleEndian);
-
-  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
-  bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
-
-  if (aIsNodata || bIsNodata ||
-      texelFloatA < filterLowA || texelFloatA > filterHighA ||
-      texelFloatB < filterLowB || texelFloatB > filterHighB
-      ) {
-    gl_FragColor = floatToRgba(nodataValue, littleEndian);
-  } else {
-    float texelFloatFinal = texelFloatA * multiplierA + texelFloatB * multiplierB;
-    gl_FragColor = floatToRgba(texelFloatFinal, littleEndian);
-  }
-}
-`