@mapwhit/tilerenderer 0.47.1

package/src/shaders/fill_extrusion.vertex.glsl

@@ -0,0 +1,66 @@
+uniform mat4 u_matrix;
+uniform vec3 u_lightcolor;
+uniform lowp vec3 u_lightpos;
+uniform lowp float u_lightintensity;
+uniform float u_vertical_gradient;
+uniform lowp float u_opacity;
+
+attribute vec2 a_pos;
+attribute vec4 a_normal_ed;
+
+varying vec4 v_color;
+
+#pragma mapbox: define lowp float base
+#pragma mapbox: define lowp float height
+
+#pragma mapbox: define highp vec4 color
+
+void main() {
+    #pragma mapbox: initialize lowp float base
+    #pragma mapbox: initialize lowp float height
+    #pragma mapbox: initialize highp vec4 color
+
+    vec3 normal = a_normal_ed.xyz;
+
+    base = max(0.0, base);
+    height = max(0.0, height);
+
+    float t = mod(normal.x, 2.0);
+
+    gl_Position = u_matrix * vec4(a_pos, t > 0.0 ? height : base, 1);
+
+    // Relative luminance (how dark/bright is the surface color?)
+    float colorvalue = color.r * 0.2126 + color.g * 0.7152 + color.b * 0.0722;
+
+    v_color = vec4(0.0, 0.0, 0.0, 1.0);
+
+    // Add slight ambient lighting so no extrusions are totally black
+    vec4 ambientlight = vec4(0.03, 0.03, 0.03, 1.0);
+    color += ambientlight;
+
+    // Calculate cos(theta), where theta is the angle between surface normal and diffuse light ray
+    float directional = clamp(dot(normal / 16384.0, u_lightpos), 0.0, 1.0);
+
+    // Adjust directional so that
+    // the range of values for highlight/shading is narrower
+    // with lower light intensity
+    // and with lighter/brighter surface colors
+    directional = mix((1.0 - u_lightintensity), max((1.0 - colorvalue + u_lightintensity), 1.0), directional);
+
+    // Add gradient along z axis of side surfaces
+    if (normal.y != 0.0) {
+        // This avoids another branching statement, but multiplies by a constant of 0.84 if no vertical gradient,
+        // and otherwise calculates the gradient based on base + height
+        directional *= (
+            (1.0 - u_vertical_gradient) +
+            (u_vertical_gradient * clamp((t + base) * pow(height / 150.0, 0.5), mix(0.7, 0.98, 1.0 - u_lightintensity), 1.0)));
+    }
+
+    // Assign final color based on surface + ambient light color, diffuse light directional, and light color
+    // with lower bounds adjusted to hue of light
+    // so that shading is tinted with the complementary (opposite) color to the light color
+    v_color.r += clamp(color.r * directional * u_lightcolor.r, mix(0.0, 0.3, 1.0 - u_lightcolor.r), 1.0);
+    v_color.g += clamp(color.g * directional * u_lightcolor.g, mix(0.0, 0.3, 1.0 - u_lightcolor.g), 1.0);
+    v_color.b += clamp(color.b * directional * u_lightcolor.b, mix(0.0, 0.3, 1.0 - u_lightcolor.b), 1.0);
+    v_color *= u_opacity;
+}

package/src/shaders/fill_extrusion_pattern.fragment.glsl

@@ -0,0 +1,41 @@
+uniform vec2 u_texsize;
+uniform float u_fade;
+
+uniform sampler2D u_image;
+
+varying vec2 v_pos_a;
+varying vec2 v_pos_b;
+varying vec4 v_lighting;
+
+#pragma mapbox: define lowp float base
+#pragma mapbox: define lowp float height
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+
+void main() {
+    #pragma mapbox: initialize lowp float base
+    #pragma mapbox: initialize lowp float height
+    #pragma mapbox: initialize mediump vec4 pattern_from
+    #pragma mapbox: initialize mediump vec4 pattern_to
+
+    vec2 pattern_tl_a = pattern_from.xy;
+    vec2 pattern_br_a = pattern_from.zw;
+    vec2 pattern_tl_b = pattern_to.xy;
+    vec2 pattern_br_b = pattern_to.zw;
+
+    vec2 imagecoord = mod(v_pos_a, 1.0);
+    vec2 pos = mix(pattern_tl_a / u_texsize, pattern_br_a / u_texsize, imagecoord);
+    vec4 color1 = texture2D(u_image, pos);
+
+    vec2 imagecoord_b = mod(v_pos_b, 1.0);
+    vec2 pos2 = mix(pattern_tl_b / u_texsize, pattern_br_b / u_texsize, imagecoord_b);
+    vec4 color2 = texture2D(u_image, pos2);
+
+    vec4 mixedColor = mix(color1, color2, u_fade);
+
+    gl_FragColor = mixedColor * v_lighting;
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/fill_extrusion_pattern.vertex.glsl

@@ -0,0 +1,76 @@
+uniform mat4 u_matrix;
+uniform vec2 u_pixel_coord_upper;
+uniform vec2 u_pixel_coord_lower;
+uniform float u_height_factor;
+uniform vec4 u_scale;
+uniform float u_vertical_gradient;
+uniform lowp float u_opacity;
+
+uniform vec3 u_lightcolor;
+uniform lowp vec3 u_lightpos;
+uniform lowp float u_lightintensity;
+
+attribute vec2 a_pos;
+attribute vec4 a_normal_ed;
+
+varying vec2 v_pos_a;
+varying vec2 v_pos_b;
+varying vec4 v_lighting;
+
+#pragma mapbox: define lowp float base
+#pragma mapbox: define lowp float height
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+
+void main() {
+    #pragma mapbox: initialize lowp float base
+    #pragma mapbox: initialize lowp float height
+    #pragma mapbox: initialize mediump vec4 pattern_from
+    #pragma mapbox: initialize mediump vec4 pattern_to
+
+    vec2 pattern_tl_a = pattern_from.xy;
+    vec2 pattern_br_a = pattern_from.zw;
+    vec2 pattern_tl_b = pattern_to.xy;
+    vec2 pattern_br_b = pattern_to.zw;
+
+    float pixelRatio = u_scale.x;
+    float tileRatio = u_scale.y;
+    float fromScale = u_scale.z;
+    float toScale = u_scale.w;
+
+    vec3 normal = a_normal_ed.xyz;
+    float edgedistance = a_normal_ed.w;
+
+    vec2 display_size_a = vec2((pattern_br_a.x - pattern_tl_a.x) / pixelRatio, (pattern_br_a.y - pattern_tl_a.y) / pixelRatio);
+    vec2 display_size_b = vec2((pattern_br_b.x - pattern_tl_b.x) / pixelRatio, (pattern_br_b.y - pattern_tl_b.y) / pixelRatio);
+
+    base = max(0.0, base);
+    height = max(0.0, height);
+
+    float t = mod(normal.x, 2.0);
+    float z = t > 0.0 ? height : base;
+
+    gl_Position = u_matrix * vec4(a_pos, z, 1);
+
+    vec2 pos = normal.x == 1.0 && normal.y == 0.0 && normal.z == 16384.0
+        ? a_pos // extrusion top
+        : vec2(edgedistance, z * u_height_factor); // extrusion side
+
+    v_pos_a = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, fromScale * display_size_a, tileRatio, pos);
+    v_pos_b = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, toScale * display_size_b, tileRatio, pos);
+
+    v_lighting = vec4(0.0, 0.0, 0.0, 1.0);
+    float directional = clamp(dot(normal / 16383.0, u_lightpos), 0.0, 1.0);
+    directional = mix((1.0 - u_lightintensity), max((0.5 + u_lightintensity), 1.0), directional);
+
+    if (normal.y != 0.0) {
+        // This avoids another branching statement, but multiplies by a constant of 0.84 if no vertical gradient,
+        // and otherwise calculates the gradient based on base + height
+        directional *= (
+            (1.0 - u_vertical_gradient) +
+            (u_vertical_gradient * clamp((t + base) * pow(height / 150.0, 0.5), mix(0.7, 0.98, 1.0 - u_lightintensity), 1.0)));
+    }
+
+    v_lighting.rgb += clamp(directional * u_lightcolor, mix(vec3(0.0), vec3(0.3), 1.0 - u_lightcolor), vec3(1.0));
+    v_lighting *= u_opacity;
+}

package/src/shaders/fill_outline.fragment.glsl

@@ -0,0 +1,17 @@
+#pragma mapbox: define highp vec4 outline_color
+#pragma mapbox: define lowp float opacity
+
+varying vec2 v_pos;
+
+void main() {
+    #pragma mapbox: initialize highp vec4 outline_color
+    #pragma mapbox: initialize lowp float opacity
+
+    float dist = length(v_pos - gl_FragCoord.xy);
+    float alpha = 1.0 - smoothstep(0.0, 1.0, dist);
+    gl_FragColor = outline_color * (alpha * opacity);
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/fill_outline.vertex.glsl

@@ -0,0 +1,17 @@
+attribute vec2 a_pos;
+
+uniform mat4 u_matrix;
+uniform vec2 u_world;
+
+varying vec2 v_pos;
+
+#pragma mapbox: define highp vec4 outline_color
+#pragma mapbox: define lowp float opacity
+
+void main() {
+    #pragma mapbox: initialize highp vec4 outline_color
+    #pragma mapbox: initialize lowp float opacity
+
+    gl_Position = u_matrix * vec4(a_pos, 0, 1);
+    v_pos = (gl_Position.xy / gl_Position.w + 1.0) / 2.0 * u_world;
+}

package/src/shaders/fill_outline_pattern.fragment.glsl

@@ -0,0 +1,43 @@
+
+uniform vec2 u_texsize;
+uniform sampler2D u_image;
+uniform float u_fade;
+
+varying vec2 v_pos_a;
+varying vec2 v_pos_b;
+varying vec2 v_pos;
+
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+
+void main() {
+    #pragma mapbox: initialize lowp float opacity
+    #pragma mapbox: initialize mediump vec4 pattern_from
+    #pragma mapbox: initialize mediump vec4 pattern_to
+
+    vec2 pattern_tl_a = pattern_from.xy;
+    vec2 pattern_br_a = pattern_from.zw;
+    vec2 pattern_tl_b = pattern_to.xy;
+    vec2 pattern_br_b = pattern_to.zw;
+
+    vec2 imagecoord = mod(v_pos_a, 1.0);
+    vec2 pos = mix(pattern_tl_a / u_texsize, pattern_br_a / u_texsize, imagecoord);
+    vec4 color1 = texture2D(u_image, pos);
+
+    vec2 imagecoord_b = mod(v_pos_b, 1.0);
+    vec2 pos2 = mix(pattern_tl_b / u_texsize, pattern_br_b / u_texsize, imagecoord_b);
+    vec4 color2 = texture2D(u_image, pos2);
+
+    // find distance to outline for alpha interpolation
+
+    float dist = length(v_pos - gl_FragCoord.xy);
+    float alpha = 1.0 - smoothstep(0.0, 1.0, dist);
+
+
+    gl_FragColor = mix(color1, color2, u_fade) * alpha * opacity;
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/fill_outline_pattern.vertex.glsl

@@ -0,0 +1,41 @@
+uniform mat4 u_matrix;
+uniform vec2 u_world;
+uniform vec2 u_pixel_coord_upper;
+uniform vec2 u_pixel_coord_lower;
+uniform vec4 u_scale;
+
+attribute vec2 a_pos;
+
+varying vec2 v_pos_a;
+varying vec2 v_pos_b;
+varying vec2 v_pos;
+
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+
+void main() {
+    #pragma mapbox: initialize lowp float opacity
+    #pragma mapbox: initialize mediump vec4 pattern_from
+    #pragma mapbox: initialize mediump vec4 pattern_to
+
+    vec2 pattern_tl_a = pattern_from.xy;
+    vec2 pattern_br_a = pattern_from.zw;
+    vec2 pattern_tl_b = pattern_to.xy;
+    vec2 pattern_br_b = pattern_to.zw;
+
+    float pixelRatio = u_scale.x;
+    float tileRatio = u_scale.y;
+    float fromScale = u_scale.z;
+    float toScale = u_scale.w;
+
+    gl_Position = u_matrix * vec4(a_pos, 0, 1);
+
+    vec2 display_size_a = vec2((pattern_br_a.x - pattern_tl_a.x) / pixelRatio, (pattern_br_a.y - pattern_tl_a.y) / pixelRatio);
+    vec2 display_size_b = vec2((pattern_br_b.x - pattern_tl_b.x) / pixelRatio, (pattern_br_b.y - pattern_tl_b.y) / pixelRatio);
+
+    v_pos_a = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, fromScale * display_size_a, tileRatio, a_pos);
+    v_pos_b = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, toScale * display_size_b, tileRatio, a_pos);
+
+    v_pos = (gl_Position.xy / gl_Position.w + 1.0) / 2.0 * u_world;
+}

package/src/shaders/fill_pattern.fragment.glsl

@@ -0,0 +1,36 @@
+uniform vec2 u_texsize;
+uniform float u_fade;
+
+uniform sampler2D u_image;
+
+varying vec2 v_pos_a;
+varying vec2 v_pos_b;
+
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+
+void main() {
+    #pragma mapbox: initialize lowp float opacity
+    #pragma mapbox: initialize mediump vec4 pattern_from
+    #pragma mapbox: initialize mediump vec4 pattern_to
+
+    vec2 pattern_tl_a = pattern_from.xy;
+    vec2 pattern_br_a = pattern_from.zw;
+    vec2 pattern_tl_b = pattern_to.xy;
+    vec2 pattern_br_b = pattern_to.zw;
+
+    vec2 imagecoord = mod(v_pos_a, 1.0);
+    vec2 pos = mix(pattern_tl_a / u_texsize, pattern_br_a / u_texsize, imagecoord);
+    vec4 color1 = texture2D(u_image, pos);
+
+    vec2 imagecoord_b = mod(v_pos_b, 1.0);
+    vec2 pos2 = mix(pattern_tl_b / u_texsize, pattern_br_b / u_texsize, imagecoord_b);
+    vec4 color2 = texture2D(u_image, pos2);
+
+    gl_FragColor = mix(color1, color2, u_fade) * opacity;
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/fill_pattern.vertex.glsl

@@ -0,0 +1,36 @@
+uniform mat4 u_matrix;
+uniform vec2 u_pixel_coord_upper;
+uniform vec2 u_pixel_coord_lower;
+uniform vec4 u_scale;
+
+attribute vec2 a_pos;
+
+varying vec2 v_pos_a;
+varying vec2 v_pos_b;
+
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+
+void main() {
+    #pragma mapbox: initialize lowp float opacity
+    #pragma mapbox: initialize mediump vec4 pattern_from
+    #pragma mapbox: initialize mediump vec4 pattern_to
+
+    vec2 pattern_tl_a = pattern_from.xy;
+    vec2 pattern_br_a = pattern_from.zw;
+    vec2 pattern_tl_b = pattern_to.xy;
+    vec2 pattern_br_b = pattern_to.zw;
+
+    float pixelRatio = u_scale.x;
+    float tileZoomRatio = u_scale.y;
+    float fromScale = u_scale.z;
+    float toScale = u_scale.w;
+
+    vec2 display_size_a = vec2((pattern_br_a.x - pattern_tl_a.x) / pixelRatio, (pattern_br_a.y - pattern_tl_a.y) / pixelRatio);
+    vec2 display_size_b = vec2((pattern_br_b.x - pattern_tl_b.x) / pixelRatio, (pattern_br_b.y - pattern_tl_b.y) / pixelRatio);
+    gl_Position = u_matrix * vec4(a_pos, 0, 1);
+
+    v_pos_a = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, fromScale * display_size_a, tileZoomRatio, a_pos);
+    v_pos_b = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, toScale * display_size_b, tileZoomRatio, a_pos);
+}

package/src/shaders/heatmap.fragment.glsl

@@ -0,0 +1,21 @@
+#pragma mapbox: define highp float weight
+
+uniform highp float u_intensity;
+varying vec2 v_extrude;
+
+// Gaussian kernel coefficient: 1 / sqrt(2 * PI)
+#define GAUSS_COEF 0.3989422804014327
+
+void main() {
+    #pragma mapbox: initialize highp float weight
+
+    // Kernel density estimation with a Gaussian kernel of size 5x5
+    float d = -0.5 * 3.0 * 3.0 * dot(v_extrude, v_extrude);
+    float val = weight * u_intensity * GAUSS_COEF * exp(d);
+
+    gl_FragColor = vec4(val, 1.0, 1.0, 1.0);
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/heatmap.vertex.glsl

@@ -0,0 +1,53 @@
+#pragma mapbox: define highp float weight
+#pragma mapbox: define mediump float radius
+
+uniform mat4 u_matrix;
+uniform float u_extrude_scale;
+uniform float u_opacity;
+uniform float u_intensity;
+
+attribute vec2 a_pos;
+
+varying vec2 v_extrude;
+
+// Effective "0" in the kernel density texture to adjust the kernel size to;
+// this empirically chosen number minimizes artifacts on overlapping kernels
+// for typical heatmap cases (assuming clustered source)
+const highp float ZERO = 1.0 / 255.0 / 16.0;
+
+// Gaussian kernel coefficient: 1 / sqrt(2 * PI)
+#define GAUSS_COEF 0.3989422804014327
+
+void main(void) {
+    #pragma mapbox: initialize highp float weight
+    #pragma mapbox: initialize mediump float radius
+
+    // unencode the extrusion vector that we snuck into the a_pos vector
+    vec2 unscaled_extrude = vec2(mod(a_pos, 2.0) * 2.0 - 1.0);
+
+    // This 'extrude' comes in ranging from [-1, -1], to [1, 1].  We'll use
+    // it to produce the vertices of a square mesh framing the point feature
+    // we're adding to the kernel density texture.  We'll also pass it as
+    // a varying, so that the fragment shader can determine the distance of
+    // each fragment from the point feature.
+    // Before we do so, we need to scale it up sufficiently so that the
+    // kernel falls effectively to zero at the edge of the mesh.
+    // That is, we want to know S such that
+    // weight * u_intensity * GAUSS_COEF * exp(-0.5 * 3.0^2 * S^2) == ZERO
+    // Which solves to:
+    // S = sqrt(-2.0 * log(ZERO / (weight * u_intensity * GAUSS_COEF))) / 3.0
+    float S = sqrt(-2.0 * log(ZERO / weight / u_intensity / GAUSS_COEF)) / 3.0;
+
+    // Pass the varying in units of radius
+    v_extrude = S * unscaled_extrude;
+
+    // Scale by radius and the zoom-based scale factor to produce actual
+    // mesh position
+    vec2 extrude = v_extrude * radius * u_extrude_scale;
+
+    // multiply a_pos by 0.5, since we had it * 2 in order to sneak
+    // in extrusion data
+    vec4 pos = vec4(floor(a_pos * 0.5) + extrude, 0, 1);
+
+    gl_Position = u_matrix * pos;
+}

package/src/shaders/heatmap_texture.fragment.glsl

@@ -0,0 +1,14 @@
+uniform sampler2D u_image;
+uniform sampler2D u_color_ramp;
+uniform float u_opacity;
+varying vec2 v_pos;
+
+void main() {
+    float t = texture2D(u_image, v_pos).r;
+    vec4 color = texture2D(u_color_ramp, vec2(t, 0.5));
+    gl_FragColor = color * u_opacity;
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(0.0);
+#endif
+}

package/src/shaders/heatmap_texture.vertex.glsl

@@ -0,0 +1,11 @@
+uniform mat4 u_matrix;
+uniform vec2 u_world;
+attribute vec2 a_pos;
+varying vec2 v_pos;
+
+void main() {
+    gl_Position = u_matrix * vec4(a_pos * u_world, 0, 1);
+
+    v_pos.x = a_pos.x;
+    v_pos.y = 1.0 - a_pos.y;
+}

package/src/shaders/hillshade.fragment.glsl

@@ -0,0 +1,52 @@
+uniform sampler2D u_image;
+varying vec2 v_pos;
+
+uniform vec2 u_latrange;
+uniform vec2 u_light;
+uniform vec4 u_shadow;
+uniform vec4 u_highlight;
+uniform vec4 u_accent;
+
+#define PI 3.141592653589793
+
+void main() {
+    vec4 pixel = texture2D(u_image, v_pos);
+
+    vec2 deriv = ((pixel.rg * 2.0) - 1.0);
+
+    // We divide the slope by a scale factor based on the cosin of the pixel's approximate latitude
+    // to account for mercator projection distortion. see #4807 for details
+    float scaleFactor = cos(radians((u_latrange[0] - u_latrange[1]) * (1.0 - v_pos.y) + u_latrange[1]));
+    // We also multiply the slope by an arbitrary z-factor of 1.25
+    float slope = atan(1.25 * length(deriv) / scaleFactor);
+    float aspect = deriv.x != 0.0 ? atan(deriv.y, -deriv.x) : PI / 2.0 * (deriv.y > 0.0 ? 1.0 : -1.0);
+
+    float intensity = u_light.x;
+    // We add PI to make this property match the global light object, which adds PI/2 to the light's azimuthal
+    // position property to account for 0deg corresponding to north/the top of the viewport in the style spec
+    // and the original shader was written to accept (-illuminationDirection - 90) as the azimuthal.
+    float azimuth = u_light.y + PI;
+
+    // We scale the slope exponentially based on intensity, using a calculation similar to
+    // the exponential interpolation function in the style spec:
+    // https://github.com/mapbox/mapbox-gl-js/blob/master/src/style-spec/expression/definitions/interpolate.js#L217-L228
+    // so that higher intensity values create more opaque hillshading.
+    float base = 1.875 - intensity * 1.75;
+    float maxValue = 0.5 * PI;
+    float scaledSlope = intensity != 0.5 ? ((pow(base, slope) - 1.0) / (pow(base, maxValue) - 1.0)) * maxValue : slope;
+
+    // The accent color is calculated with the cosine of the slope while the shade color is calculated with the sine
+    // so that the accent color's rate of change eases in while the shade color's eases out.
+    float accent = cos(scaledSlope);
+    // We multiply both the accent and shade color by a clamped intensity value
+    // so that intensities >= 0.5 do not additionally affect the color values
+    // while intensity values < 0.5 make the overall color more transparent.
+    vec4 accent_color = (1.0 - accent) * u_accent * clamp(intensity * 2.0, 0.0, 1.0);
+    float shade = abs(mod((aspect + azimuth) / PI + 0.5, 2.0) - 1.0);
+    vec4 shade_color = mix(u_shadow, u_highlight, shade) * sin(scaledSlope) * clamp(intensity * 2.0, 0.0, 1.0);
+    gl_FragColor = accent_color * (1.0 - shade_color.a) + shade_color;
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/hillshade.vertex.glsl

@@ -0,0 +1,11 @@
+uniform mat4 u_matrix;
+
+attribute vec2 a_pos;
+attribute vec2 a_texture_pos;
+
+varying vec2 v_pos;
+
+void main() {
+    gl_Position = u_matrix * vec4(a_pos, 0, 1);
+    v_pos = a_texture_pos / 8192.0;
+}

package/src/shaders/hillshade_prepare.fragment.glsl

@@ -0,0 +1,72 @@
+#ifdef GL_ES
+precision highp float;
+#endif
+
+uniform sampler2D u_image;
+varying vec2 v_pos;
+uniform vec2 u_dimension;
+uniform float u_zoom;
+uniform float u_maxzoom;
+
+float getElevation(vec2 coord, float bias) {
+    // Convert encoded elevation value to meters
+    vec4 data = texture2D(u_image, coord) * 255.0;
+    return (data.r + data.g * 256.0 + data.b * 256.0 * 256.0) / 4.0;
+}
+
+void main() {
+    vec2 epsilon = 1.0 / u_dimension;
+
+    // queried pixels:
+    // +-----------+
+    // |   |   |   |
+    // | a | b | c |
+    // |   |   |   |
+    // +-----------+
+    // |   |   |   |
+    // | d | e | f |
+    // |   |   |   |
+    // +-----------+
+    // |   |   |   |
+    // | g | h | i |
+    // |   |   |   |
+    // +-----------+
+
+    float a = getElevation(v_pos + vec2(-epsilon.x, -epsilon.y), 0.0);
+    float b = getElevation(v_pos + vec2(0, -epsilon.y), 0.0);
+    float c = getElevation(v_pos + vec2(epsilon.x, -epsilon.y), 0.0);
+    float d = getElevation(v_pos + vec2(-epsilon.x, 0), 0.0);
+    float e = getElevation(v_pos, 0.0);
+    float f = getElevation(v_pos + vec2(epsilon.x, 0), 0.0);
+    float g = getElevation(v_pos + vec2(-epsilon.x, epsilon.y), 0.0);
+    float h = getElevation(v_pos + vec2(0, epsilon.y), 0.0);
+    float i = getElevation(v_pos + vec2(epsilon.x, epsilon.y), 0.0);
+
+    // here we divide the x and y slopes by 8 * pixel size
+    // where pixel size (aka meters/pixel) is:
+    // circumference of the world / (pixels per tile * number of tiles)
+    // which is equivalent to: 8 * 40075016.6855785 / (512 * pow(2, u_zoom))
+    // which can be reduced to: pow(2, 19.25619978527 - u_zoom)
+    // we want to vertically exaggerate the hillshading though, because otherwise
+    // it is barely noticeable at low zooms. to do this, we multiply this by some
+    // scale factor pow(2, (u_zoom - u_maxzoom) * a) where a is an arbitrary value
+    // Here we use a=0.3 which works out to the expression below. see 
+    // nickidlugash's awesome breakdown for more info
+    // https://github.com/mapbox/mapbox-gl-js/pull/5286#discussion_r148419556
+    float exaggeration = u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;
+
+    vec2 deriv = vec2(
+        (c + f + f + i) - (a + d + d + g),
+        (g + h + h + i) - (a + b + b + c)
+    ) /  pow(2.0, (u_zoom - u_maxzoom) * exaggeration + 19.2562 - u_zoom);
+
+    gl_FragColor = clamp(vec4(
+        deriv.x / 2.0 + 0.5,
+        deriv.y / 2.0 + 0.5,
+        1.0,
+        1.0), 0.0, 1.0);
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/hillshade_prepare.vertex.glsl

@@ -0,0 +1,15 @@
+uniform mat4 u_matrix;
+uniform vec2 u_dimension;
+
+attribute vec2 a_pos;
+attribute vec2 a_texture_pos;
+
+varying vec2 v_pos;
+
+void main() {
+    gl_Position = u_matrix * vec4(a_pos, 0, 1);
+
+    vec2 epsilon = 1.0 / u_dimension;
+    float scale = (u_dimension.x - 2.0) / u_dimension.x;
+    v_pos = (a_texture_pos / 8192.0) * scale + epsilon;
+}