@mapwhit/tilerenderer 0.47.1

package/src/shaders/index.js

@@ -0,0 +1,194 @@
+const shaders = {
+  prelude: {
+    fragmentSource: require('../../build/min/src/shaders/_prelude.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/_prelude.vertex.glsl.txt')
+  },
+  background: {
+    fragmentSource: require('../../build/min/src/shaders/background.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/background.vertex.glsl.txt')
+  },
+  backgroundPattern: {
+    fragmentSource: require('../../build/min/src/shaders/background_pattern.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/background_pattern.vertex.glsl.txt')
+  },
+  circle: {
+    fragmentSource: require('../../build/min/src/shaders/circle.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/circle.vertex.glsl.txt')
+  },
+  clippingMask: {
+    fragmentSource: require('../../build/min/src/shaders/clipping_mask.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/clipping_mask.vertex.glsl.txt')
+  },
+  heatmap: {
+    fragmentSource: require('../../build/min/src/shaders/heatmap.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/heatmap.vertex.glsl.txt')
+  },
+  heatmapTexture: {
+    fragmentSource: require('../../build/min/src/shaders/heatmap_texture.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/heatmap_texture.vertex.glsl.txt')
+  },
+  collisionBox: {
+    fragmentSource: require('../../build/min/src/shaders/collision_box.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/collision_box.vertex.glsl.txt')
+  },
+  collisionCircle: {
+    fragmentSource: require('../../build/min/src/shaders/collision_circle.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/collision_circle.vertex.glsl.txt')
+  },
+  debug: {
+    fragmentSource: require('../../build/min/src/shaders/debug.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/debug.vertex.glsl.txt')
+  },
+  fill: {
+    fragmentSource: require('../../build/min/src/shaders/fill.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/fill.vertex.glsl.txt')
+  },
+  fillOutline: {
+    fragmentSource: require('../../build/min/src/shaders/fill_outline.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/fill_outline.vertex.glsl.txt')
+  },
+  fillOutlinePattern: {
+    fragmentSource: require('../../build/min/src/shaders/fill_outline_pattern.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/fill_outline_pattern.vertex.glsl.txt')
+  },
+  fillPattern: {
+    fragmentSource: require('../../build/min/src/shaders/fill_pattern.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/fill_pattern.vertex.glsl.txt')
+  },
+  fillExtrusion: {
+    fragmentSource: require('../../build/min/src/shaders/fill_extrusion.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/fill_extrusion.vertex.glsl.txt')
+  },
+  fillExtrusionPattern: {
+    fragmentSource: require('../../build/min/src/shaders/fill_extrusion_pattern.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/fill_extrusion_pattern.vertex.glsl.txt')
+  },
+  hillshadePrepare: {
+    fragmentSource: require('../../build/min/src/shaders/hillshade_prepare.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/hillshade_prepare.vertex.glsl.txt')
+  },
+  hillshade: {
+    fragmentSource: require('../../build/min/src/shaders/hillshade.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/hillshade.vertex.glsl.txt')
+  },
+  line: {
+    fragmentSource: require('../../build/min/src/shaders/line.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/line.vertex.glsl.txt')
+  },
+  lineGradient: {
+    fragmentSource: require('../../build/min/src/shaders/line_gradient.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/line_gradient.vertex.glsl.txt')
+  },
+  linePattern: {
+    fragmentSource: require('../../build/min/src/shaders/line_pattern.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/line_pattern.vertex.glsl.txt')
+  },
+  lineSDF: {
+    fragmentSource: require('../../build/min/src/shaders/line_sdf.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/line_sdf.vertex.glsl.txt')
+  },
+  raster: {
+    fragmentSource: require('../../build/min/src/shaders/raster.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/raster.vertex.glsl.txt')
+  },
+  symbolIcon: {
+    fragmentSource: require('../../build/min/src/shaders/symbol_icon.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/symbol_icon.vertex.glsl.txt')
+  },
+  symbolSDF: {
+    fragmentSource: require('../../build/min/src/shaders/symbol_sdf.fragment.glsl.txt'),
+    vertexSource: require('../../build/min/src/shaders/symbol_sdf.vertex.glsl.txt')
+  }
+};
+
+// Expand #pragmas to #ifdefs.
+
+const re = /#pragma mapbox: ([\w]+) ([\w]+) ([\w]+) ([\w]+)/g;
+
+for (const programName in shaders) {
+  const program = shaders[programName];
+  const fragmentPragmas = {};
+
+  program.fragmentSource = program.fragmentSource.replace(re, (match, operation, precision, type, name) => {
+    fragmentPragmas[name] = true;
+    if (operation === 'define') {
+      return `
+#ifndef HAS_UNIFORM_u_${name}
+varying ${precision} ${type} ${name};
+#else
+uniform ${precision} ${type} u_${name};
+#endif
+`;
+    }
+    return `
+#ifdef HAS_UNIFORM_u_${name}
+    ${precision} ${type} ${name} = u_${name};
+#endif
+`;
+  });
+
+  program.vertexSource = program.vertexSource.replace(re, (match, operation, precision, type, name) => {
+    const attrType = type === 'float' ? 'vec2' : 'vec4';
+    const unpackType = name.match(/color/) ? 'color' : attrType;
+
+    if (fragmentPragmas[name]) {
+      if (operation === 'define') {
+        return `
+#ifndef HAS_UNIFORM_u_${name}
+uniform lowp float a_${name}_t;
+attribute ${precision} ${attrType} a_${name};
+varying ${precision} ${type} ${name};
+#else
+uniform ${precision} ${type} u_${name};
+#endif
+`;
+      }
+      if (unpackType === 'vec4') {
+        // vec4 attributes are only used for cross-faded properties, and are not packed
+        return `
+#ifndef HAS_UNIFORM_u_${name}
+${name} = a_${name};
+#else
+${precision} ${type} ${name} = u_${name};
+#endif
+`;
+      }
+      return `
+#ifndef HAS_UNIFORM_u_${name}
+    ${name} = unpack_mix_${unpackType}(a_${name}, a_${name}_t);
+#else
+    ${precision} ${type} ${name} = u_${name};
+#endif
+`;
+    }
+    if (operation === 'define') {
+      return `
+#ifndef HAS_UNIFORM_u_${name}
+uniform lowp float a_${name}_t;
+attribute ${precision} ${attrType} a_${name};
+#else
+uniform ${precision} ${type} u_${name};
+#endif
+`;
+    }
+    if (unpackType === 'vec4') {
+      // vec4 attributes are only used for cross-faded properties, and are not packed
+      return `
+#ifndef HAS_UNIFORM_u_${name}
+${precision} ${type} ${name} = a_${name};
+#else
+${precision} ${type} ${name} = u_${name};
+#endif
+`;
+    }
+    return `
+#ifndef HAS_UNIFORM_u_${name}
+    ${precision} ${type} ${name} = unpack_mix_${unpackType}(a_${name}, a_${name}_t);
+#else
+    ${precision} ${type} ${name} = u_${name};
+#endif
+`;
+  });
+}
+
+module.exports = shaders;

package/src/shaders/line.fragment.glsl

@@ -0,0 +1,28 @@
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+
+varying vec2 v_width2;
+varying vec2 v_normal;
+varying float v_gamma_scale;
+
+void main() {
+    #pragma mapbox: initialize highp vec4 color
+    #pragma mapbox: initialize lowp float blur
+    #pragma mapbox: initialize lowp float opacity
+
+    // Calculate the distance of the pixel from the line in pixels.
+    float dist = length(v_normal) * v_width2.s;
+
+    // Calculate the antialiasing fade factor. This is either when fading in
+    // the line in case of an offset line (v_width2.t) or when fading out
+    // (v_width2.s)
+    float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;
+    float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);
+
+    gl_FragColor = color * (alpha * opacity);
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/line.vertex.glsl

@@ -0,0 +1,84 @@
+
+
+// the distance over which the line edge fades out.
+// Retina devices need a smaller distance to avoid aliasing.
+#define ANTIALIASING 1.0 / DEVICE_PIXEL_RATIO / 2.0
+
+// floor(127 / 2) == 63.0
+// the maximum allowed miter limit is 2.0 at the moment. the extrude normal is
+// stored in a byte (-128..127). we scale regular normals up to length 63, but
+// there are also "special" normals that have a bigger length (of up to 126 in
+// this case).
+// #define scale 63.0
+#define scale 0.015873016
+
+attribute vec4 a_pos_normal;
+attribute vec4 a_data;
+
+uniform mat4 u_matrix;
+uniform mediump float u_ratio;
+uniform vec2 u_gl_units_to_pixels;
+
+varying vec2 v_normal;
+varying vec2 v_width2;
+varying float v_gamma_scale;
+varying highp float v_linesofar;
+
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define mediump float gapwidth
+#pragma mapbox: define lowp float offset
+#pragma mapbox: define mediump float width
+
+void main() {
+    #pragma mapbox: initialize highp vec4 color
+    #pragma mapbox: initialize lowp float blur
+    #pragma mapbox: initialize lowp float opacity
+    #pragma mapbox: initialize mediump float gapwidth
+    #pragma mapbox: initialize lowp float offset
+    #pragma mapbox: initialize mediump float width
+
+    vec2 a_extrude = a_data.xy - 128.0;
+    float a_direction = mod(a_data.z, 4.0) - 1.0;
+
+    v_linesofar = (floor(a_data.z / 4.0) + a_data.w * 64.0) * 2.0;
+
+    vec2 pos = a_pos_normal.xy;
+
+    // x is 1 if it's a round cap, 0 otherwise
+    // y is 1 if the normal points up, and -1 if it points down
+    mediump vec2 normal = a_pos_normal.zw;
+    v_normal = normal;
+
+    // these transformations used to be applied in the JS and native code bases.
+    // moved them into the shader for clarity and simplicity.
+    gapwidth = gapwidth / 2.0;
+    float halfwidth = width / 2.0;
+    offset = -1.0 * offset;
+
+    float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0);
+    float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + (halfwidth == 0.0 ? 0.0 : ANTIALIASING);
+
+    // Scale the extrusion vector down to a normal and then up by the line width
+    // of this vertex.
+    mediump vec2 dist = outset * a_extrude * scale;
+
+    // Calculate the offset when drawing a line that is to the side of the actual line.
+    // We do this by creating a vector that points towards the extrude, but rotate
+    // it when we're drawing round end points (a_direction = -1 or 1) since their
+    // extrude vector points in another direction.
+    mediump float u = 0.5 * a_direction;
+    mediump float t = 1.0 - abs(u);
+    mediump vec2 offset2 = offset * a_extrude * scale * normal.y * mat2(t, -u, u, t);
+
+    vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0);
+    gl_Position = u_matrix * vec4(pos + offset2 / u_ratio, 0.0, 1.0) + projected_extrude;
+
+    // calculate how much the perspective view squishes or stretches the extrude
+    float extrude_length_without_perspective = length(dist);
+    float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels);
+    v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;
+
+    v_width2 = vec2(outset, inset);
+}

package/src/shaders/line_gradient.fragment.glsl

@@ -0,0 +1,34 @@
+
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+
+uniform sampler2D u_image;
+
+varying vec2 v_width2;
+varying vec2 v_normal;
+varying float v_gamma_scale;
+varying highp float v_lineprogress;
+
+void main() {
+    #pragma mapbox: initialize lowp float blur
+    #pragma mapbox: initialize lowp float opacity
+
+    // Calculate the distance of the pixel from the line in pixels.
+    float dist = length(v_normal) * v_width2.s;
+
+    // Calculate the antialiasing fade factor. This is either when fading in
+    // the line in case of an offset line (v_width2.t) or when fading out
+    // (v_width2.s)
+    float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;
+    float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);
+
+    // For gradient lines, v_lineprogress is the ratio along the entire line,
+    // scaled to [0, 2^15), and the gradient ramp is stored in a texture.
+    vec4 color = texture2D(u_image, vec2(v_lineprogress, 0.5));
+
+    gl_FragColor = color * (alpha * opacity);
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/line_gradient.vertex.glsl

@@ -0,0 +1,84 @@
+
+// the attribute conveying progress along a line is scaled to [0, 2^15)
+#define MAX_LINE_DISTANCE 32767.0
+
+// the distance over which the line edge fades out.
+// Retina devices need a smaller distance to avoid aliasing.
+#define ANTIALIASING 1.0 / DEVICE_PIXEL_RATIO / 2.0
+
+// floor(127 / 2) == 63.0
+// the maximum allowed miter limit is 2.0 at the moment. the extrude normal is
+// stored in a byte (-128..127). we scale regular normals up to length 63, but
+// there are also "special" normals that have a bigger length (of up to 126 in
+// this case).
+// #define scale 63.0
+#define scale 0.015873016
+
+attribute vec4 a_pos_normal;
+attribute vec4 a_data;
+
+uniform mat4 u_matrix;
+uniform mediump float u_ratio;
+uniform vec2 u_gl_units_to_pixels;
+
+varying vec2 v_normal;
+varying vec2 v_width2;
+varying float v_gamma_scale;
+varying highp float v_lineprogress;
+
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define mediump float gapwidth
+#pragma mapbox: define lowp float offset
+#pragma mapbox: define mediump float width
+
+void main() {
+    #pragma mapbox: initialize lowp float blur
+    #pragma mapbox: initialize lowp float opacity
+    #pragma mapbox: initialize mediump float gapwidth
+    #pragma mapbox: initialize lowp float offset
+    #pragma mapbox: initialize mediump float width
+
+    vec2 a_extrude = a_data.xy - 128.0;
+    float a_direction = mod(a_data.z, 4.0) - 1.0;
+
+    v_lineprogress = (floor(a_data.z / 4.0) + a_data.w * 64.0) * 2.0 / MAX_LINE_DISTANCE;
+
+    vec2 pos = a_pos_normal.xy;
+
+    // x is 1 if it's a round cap, 0 otherwise
+    // y is 1 if the normal points up, and -1 if it points down
+    mediump vec2 normal = a_pos_normal.zw;
+    v_normal = normal;
+
+    // these transformations used to be applied in the JS and native code bases.
+    // moved them into the shader for clarity and simplicity.
+    gapwidth = gapwidth / 2.0;
+    float halfwidth = width / 2.0;
+    offset = -1.0 * offset;
+
+    float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0);
+    float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + (halfwidth == 0.0 ? 0.0 : ANTIALIASING);
+
+    // Scale the extrusion vector down to a normal and then up by the line width
+    // of this vertex.
+    mediump vec2 dist = outset * a_extrude * scale;
+
+    // Calculate the offset when drawing a line that is to the side of the actual line.
+    // We do this by creating a vector that points towards the extrude, but rotate
+    // it when we're drawing round end points (a_direction = -1 or 1) since their
+    // extrude vector points in another direction.
+    mediump float u = 0.5 * a_direction;
+    mediump float t = 1.0 - abs(u);
+    mediump vec2 offset2 = offset * a_extrude * scale * normal.y * mat2(t, -u, u, t);
+
+    vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0);
+    gl_Position = u_matrix * vec4(pos + offset2 / u_ratio, 0.0, 1.0) + projected_extrude;
+
+    // calculate how much the perspective view squishes or stretches the extrude
+    float extrude_length_without_perspective = length(dist);
+    float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels);
+    v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;
+
+    v_width2 = vec2(outset, inset);
+}

package/src/shaders/line_pattern.fragment.glsl

@@ -0,0 +1,69 @@
+uniform vec2 u_texsize;
+uniform float u_fade;
+uniform mediump vec4 u_scale;
+
+uniform sampler2D u_image;
+
+varying vec2 v_normal;
+varying vec2 v_width2;
+varying float v_linesofar;
+varying float v_gamma_scale;
+
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+
+void main() {
+    #pragma mapbox: initialize mediump vec4 pattern_from
+    #pragma mapbox: initialize mediump vec4 pattern_to
+
+    #pragma mapbox: initialize lowp float blur
+    #pragma mapbox: initialize lowp float opacity
+
+    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);
+
+    vec2 pattern_size_a = vec2(display_size_a.x * fromScale / tileZoomRatio, display_size_a.y);
+    vec2 pattern_size_b = vec2(display_size_b.x * toScale / tileZoomRatio, display_size_b.y);
+
+    // Calculate the distance of the pixel from the line in pixels.
+    float dist = length(v_normal) * v_width2.s;
+
+    // Calculate the antialiasing fade factor. This is either when fading in
+    // the line in case of an offset line (v_width2.t) or when fading out
+    // (v_width2.s)
+    float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;
+    float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);
+
+    float x_a = mod(v_linesofar / pattern_size_a.x, 1.0);
+    float x_b = mod(v_linesofar / pattern_size_b.x, 1.0);
+
+    // v_normal.y is 0 at the midpoint of the line, -1 at the lower edge, 1 at the upper edge
+    // we clamp the line width outset to be between 0 and half the pattern height plus padding (2.0)
+    // to ensure we don't sample outside the designated symbol on the sprite sheet.
+    // 0.5 is added to shift the component to be bounded between 0 and 1 for interpolation of
+    // the texture coordinate
+    float y_a = 0.5 + (v_normal.y * clamp(v_width2.s, 0.0, (pattern_size_a.y + 2.0) / 2.0) / pattern_size_a.y);
+    float y_b = 0.5 + (v_normal.y * clamp(v_width2.s, 0.0, (pattern_size_b.y + 2.0) / 2.0) / pattern_size_b.y);
+    vec2 pos_a = mix(pattern_tl_a / u_texsize, pattern_br_a / u_texsize, vec2(x_a, y_a));
+    vec2 pos_b = mix(pattern_tl_b / u_texsize, pattern_br_b / u_texsize, vec2(x_b, y_b));
+
+    vec4 color = mix(texture2D(u_image, pos_a), texture2D(u_image, pos_b), u_fade);
+
+    gl_FragColor = color * alpha * opacity;
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/line_pattern.vertex.glsl

@@ -0,0 +1,88 @@
+// floor(127 / 2) == 63.0
+// the maximum allowed miter limit is 2.0 at the moment. the extrude normal is
+// stored in a byte (-128..127). we scale regular normals up to length 63, but
+// there are also "special" normals that have a bigger length (of up to 126 in
+// this case).
+// #define scale 63.0
+#define scale 0.015873016
+
+// We scale the distance before adding it to the buffers so that we can store
+// long distances for long segments. Use this value to unscale the distance.
+#define LINE_DISTANCE_SCALE 2.0
+
+// the distance over which the line edge fades out.
+// Retina devices need a smaller distance to avoid aliasing.
+#define ANTIALIASING 1.0 / DEVICE_PIXEL_RATIO / 2.0
+
+attribute vec4 a_pos_normal;
+attribute vec4 a_data;
+
+uniform mat4 u_matrix;
+uniform vec2 u_gl_units_to_pixels;
+uniform mediump float u_ratio;
+
+varying vec2 v_normal;
+varying vec2 v_width2;
+varying float v_linesofar;
+varying float v_gamma_scale;
+
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define lowp float offset
+#pragma mapbox: define mediump float gapwidth
+#pragma mapbox: define mediump float width
+#pragma mapbox: define lowp vec4 pattern_from
+#pragma mapbox: define lowp vec4 pattern_to
+
+void main() {
+    #pragma mapbox: initialize lowp float blur
+    #pragma mapbox: initialize lowp float opacity
+    #pragma mapbox: initialize lowp float offset
+    #pragma mapbox: initialize mediump float gapwidth
+    #pragma mapbox: initialize mediump float width
+    #pragma mapbox: initialize mediump vec4 pattern_from
+    #pragma mapbox: initialize mediump vec4 pattern_to
+
+    vec2 a_extrude = a_data.xy - 128.0;
+    float a_direction = mod(a_data.z, 4.0) - 1.0;
+    float a_linesofar = (floor(a_data.z / 4.0) + a_data.w * 64.0) * LINE_DISTANCE_SCALE;
+    // float tileRatio = u_scale.y;
+    vec2 pos = a_pos_normal.xy;
+
+    // x is 1 if it's a round cap, 0 otherwise
+    // y is 1 if the normal points up, and -1 if it points down
+    mediump vec2 normal = a_pos_normal.zw;
+    v_normal = normal;
+
+    // these transformations used to be applied in the JS and native code bases.
+    // moved them into the shader for clarity and simplicity.
+    gapwidth = gapwidth / 2.0;
+    float halfwidth = width / 2.0;
+    offset = -1.0 * offset;
+
+    float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0);
+    float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + (halfwidth == 0.0 ? 0.0 : ANTIALIASING);
+
+    // Scale the extrusion vector down to a normal and then up by the line width
+    // of this vertex.
+    mediump vec2 dist = outset * a_extrude * scale;
+
+    // Calculate the offset when drawing a line that is to the side of the actual line.
+    // We do this by creating a vector that points towards the extrude, but rotate
+    // it when we're drawing round end points (a_direction = -1 or 1) since their
+    // extrude vector points in another direction.
+    mediump float u = 0.5 * a_direction;
+    mediump float t = 1.0 - abs(u);
+    mediump vec2 offset2 = offset * a_extrude * scale * normal.y * mat2(t, -u, u, t);
+
+    vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0);
+    gl_Position = u_matrix * vec4(pos + offset2 / u_ratio, 0.0, 1.0) + projected_extrude;
+
+    // calculate how much the perspective view squishes or stretches the extrude
+    float extrude_length_without_perspective = length(dist);
+    float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels);
+    v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;
+
+    v_linesofar = a_linesofar;
+    v_width2 = vec2(outset, inset);
+}

package/src/shaders/line_sdf.fragment.glsl

@@ -0,0 +1,44 @@
+
+uniform sampler2D u_image;
+uniform float u_sdfgamma;
+uniform float u_mix;
+
+varying vec2 v_normal;
+varying vec2 v_width2;
+varying vec2 v_tex_a;
+varying vec2 v_tex_b;
+varying float v_gamma_scale;
+
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define mediump float width
+#pragma mapbox: define lowp float floorwidth
+
+void main() {
+    #pragma mapbox: initialize highp vec4 color
+    #pragma mapbox: initialize lowp float blur
+    #pragma mapbox: initialize lowp float opacity
+    #pragma mapbox: initialize mediump float width
+    #pragma mapbox: initialize lowp float floorwidth
+
+    // Calculate the distance of the pixel from the line in pixels.
+    float dist = length(v_normal) * v_width2.s;
+
+    // Calculate the antialiasing fade factor. This is either when fading in
+    // the line in case of an offset line (v_width2.t) or when fading out
+    // (v_width2.s)
+    float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;
+    float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);
+
+    float sdfdist_a = texture2D(u_image, v_tex_a).a;
+    float sdfdist_b = texture2D(u_image, v_tex_b).a;
+    float sdfdist = mix(sdfdist_a, sdfdist_b, u_mix);
+    alpha *= smoothstep(0.5 - u_sdfgamma / floorwidth, 0.5 + u_sdfgamma / floorwidth, sdfdist);
+
+    gl_FragColor = color * (alpha * opacity);
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}