mapbox-gl 1.13.2

package/src/render/vertex_array_object.js

@@ -0,0 +1,163 @@
+// @flow
+
+import assert from 'assert';
+
+import type Program from './program';
+import type VertexBuffer from '../gl/vertex_buffer';
+import type IndexBuffer from '../gl/index_buffer';
+import type Context from '../gl/context';
+
+class VertexArrayObject {
+    context: Context;
+    boundProgram: ?Program<*>;
+    boundLayoutVertexBuffer: ?VertexBuffer;
+    boundPaintVertexBuffers: Array<VertexBuffer>;
+    boundIndexBuffer: ?IndexBuffer;
+    boundVertexOffset: ?number;
+    boundDynamicVertexBuffer: ?VertexBuffer;
+    boundDynamicVertexBuffer2: ?VertexBuffer;
+    vao: any;
+
+    constructor() {
+        this.boundProgram = null;
+        this.boundLayoutVertexBuffer = null;
+        this.boundPaintVertexBuffers = [];
+        this.boundIndexBuffer = null;
+        this.boundVertexOffset = null;
+        this.boundDynamicVertexBuffer = null;
+        this.vao = null;
+    }
+
+    bind(context: Context,
+         program: Program<*>,
+         layoutVertexBuffer: VertexBuffer,
+         paintVertexBuffers: Array<VertexBuffer>,
+         indexBuffer: ?IndexBuffer,
+         vertexOffset: ?number,
+         dynamicVertexBuffer: ?VertexBuffer,
+         dynamicVertexBuffer2: ?VertexBuffer) {
+
+        this.context = context;
+
+        let paintBuffersDiffer = this.boundPaintVertexBuffers.length !== paintVertexBuffers.length;
+        for (let i = 0; !paintBuffersDiffer && i < paintVertexBuffers.length; i++) {
+            if (this.boundPaintVertexBuffers[i] !== paintVertexBuffers[i]) {
+                paintBuffersDiffer = true;
+            }
+        }
+
+        const isFreshBindRequired = (
+            !this.vao ||
+            this.boundProgram !== program ||
+            this.boundLayoutVertexBuffer !== layoutVertexBuffer ||
+            paintBuffersDiffer ||
+            this.boundIndexBuffer !== indexBuffer ||
+            this.boundVertexOffset !== vertexOffset ||
+            this.boundDynamicVertexBuffer !== dynamicVertexBuffer ||
+            this.boundDynamicVertexBuffer2 !== dynamicVertexBuffer2
+        );
+
+        if (!context.extVertexArrayObject || isFreshBindRequired) {
+            this.freshBind(program, layoutVertexBuffer, paintVertexBuffers, indexBuffer, vertexOffset, dynamicVertexBuffer, dynamicVertexBuffer2);
+        } else {
+            context.bindVertexArrayOES.set(this.vao);
+
+            if (dynamicVertexBuffer) {
+                // The buffer may have been updated. Rebind to upload data.
+                dynamicVertexBuffer.bind();
+            }
+
+            if (indexBuffer && indexBuffer.dynamicDraw) {
+                indexBuffer.bind();
+            }
+
+            if (dynamicVertexBuffer2) {
+                dynamicVertexBuffer2.bind();
+            }
+        }
+    }
+
+    freshBind(program: Program<*>,
+              layoutVertexBuffer: VertexBuffer,
+              paintVertexBuffers: Array<VertexBuffer>,
+              indexBuffer: ?IndexBuffer,
+              vertexOffset: ?number,
+              dynamicVertexBuffer: ?VertexBuffer,
+              dynamicVertexBuffer2: ?VertexBuffer) {
+        let numPrevAttributes;
+        const numNextAttributes = program.numAttributes;
+
+        const context = this.context;
+        const gl = context.gl;
+
+        if (context.extVertexArrayObject) {
+            if (this.vao) this.destroy();
+            this.vao = context.extVertexArrayObject.createVertexArrayOES();
+            context.bindVertexArrayOES.set(this.vao);
+            numPrevAttributes = 0;
+
+            // store the arguments so that we can verify them when the vao is bound again
+            this.boundProgram = program;
+            this.boundLayoutVertexBuffer = layoutVertexBuffer;
+            this.boundPaintVertexBuffers = paintVertexBuffers;
+            this.boundIndexBuffer = indexBuffer;
+            this.boundVertexOffset = vertexOffset;
+            this.boundDynamicVertexBuffer = dynamicVertexBuffer;
+            this.boundDynamicVertexBuffer2 = dynamicVertexBuffer2;
+
+        } else {
+            numPrevAttributes = context.currentNumAttributes || 0;
+
+            // Disable all attributes from the previous program that aren't used in
+            // the new program. Note: attribute indices are *not* program specific!
+            for (let i = numNextAttributes; i < numPrevAttributes; i++) {
+                // WebGL breaks if you disable attribute 0.
+                // http://stackoverflow.com/questions/20305231
+                assert(i !== 0);
+                gl.disableVertexAttribArray(i);
+            }
+        }
+
+        layoutVertexBuffer.enableAttributes(gl, program);
+        for (const vertexBuffer of paintVertexBuffers) {
+            vertexBuffer.enableAttributes(gl, program);
+        }
+
+        if (dynamicVertexBuffer) {
+            dynamicVertexBuffer.enableAttributes(gl, program);
+        }
+        if (dynamicVertexBuffer2) {
+            dynamicVertexBuffer2.enableAttributes(gl, program);
+        }
+
+        layoutVertexBuffer.bind();
+        layoutVertexBuffer.setVertexAttribPointers(gl, program, vertexOffset);
+        for (const vertexBuffer of paintVertexBuffers) {
+            vertexBuffer.bind();
+            vertexBuffer.setVertexAttribPointers(gl, program, vertexOffset);
+        }
+
+        if (dynamicVertexBuffer) {
+            dynamicVertexBuffer.bind();
+            dynamicVertexBuffer.setVertexAttribPointers(gl, program, vertexOffset);
+        }
+        if (indexBuffer) {
+            indexBuffer.bind();
+        }
+        if (dynamicVertexBuffer2) {
+            dynamicVertexBuffer2.bind();
+            dynamicVertexBuffer2.setVertexAttribPointers(gl, program, vertexOffset);
+        }
+
+        context.currentNumAttributes = numNextAttributes;
+    }
+
+    destroy() {
+        if (this.vao) {
+            this.context.extVertexArrayObject.deleteVertexArrayOES(this.vao);
+            this.vao = null;
+        }
+    }
+}
+
+export default VertexArrayObject;

package/src/shaders/README.md

@@ -0,0 +1,42 @@
+# Mapbox GL Shaders
+
+This repository contains GL shaders which are shared by [Mapbox GL JS](https://github.com/mapbox/mapbox-gl-js) and [Mapbox GL Native](https://github.com/mapbox/mapbox-gl-native).
+
+## Pragmas
+
+Some variables change type depending on their context:
+
+ - if the variable is the same for all features, we declare it as a `uniform`
+ - if the variable is different for each feature, we declare it as an `attribute` (in the vertex shader) and an accompanying `varying` (in both the vertex and fragment shaders).
+ - if the variable is different for each feature and a function of zoom, we declare several `attributes` and `uniforms` then calculate the value using interpolation
+
+We abstract over this functionality using pragmas.
+
+```glsl
+#pragma mapbox: define highp vec4 color
+
+main() {
+    #pragma mapbox: initialize highp vec4 color
+    ...
+    gl_FragColor = color;
+}
+```
+
+This program defines a variable within `main` called `color`, initialize the value of `color`, then sets `gl_FragColor` to the value of `color`.
+
+Pragmas take the following form.
+
+```glsl
+#pragma mapbox: (define|initialize) (lowp|mediump|highp) (float|vec2|vec3|vec4) {name}
+```
+
+When using pragmas, the following requirements apply.
+
+ - all pragma-defined variables must have both `define` and `initialize` pragmas
+ - `define` pragmas must be in file scope
+ - `initialize` pragmas must be in function scope
+ - all pragma-defined variables defined and initialized in the fragment shader must also be defined and initialized in the vertex shader because `attribute`s are not accessible from the fragment shader
+
+## Prelude
+
+The `_prelude.fragment.glsl` and `_prelude.vertex.glsl` files are automatically included in all shaders by the compiler.

package/src/shaders/_prelude.fragment.glsl

@@ -0,0 +1,17 @@
+#ifdef GL_ES
+precision mediump float;
+#else
+
+#if !defined(lowp)
+#define lowp
+#endif
+
+#if !defined(mediump)
+#define mediump
+#endif
+
+#if !defined(highp)
+#define highp
+#endif
+
+#endif

package/src/shaders/_prelude.vertex.glsl

@@ -0,0 +1,73 @@
+#ifdef GL_ES
+precision highp float;
+#else
+
+#if !defined(lowp)
+#define lowp
+#endif
+
+#if !defined(mediump)
+#define mediump
+#endif
+
+#if !defined(highp)
+#define highp
+#endif
+
+#endif
+
+// Unpack a pair of values that have been packed into a single float.
+// The packed values are assumed to be 8-bit unsigned integers, and are
+// packed like so:
+// packedValue = floor(input[0]) * 256 + input[1],
+vec2 unpack_float(const float packedValue) {
+    int packedIntValue = int(packedValue);
+    int v0 = packedIntValue / 256;
+    return vec2(v0, packedIntValue - v0 * 256);
+}
+
+vec2 unpack_opacity(const float packedOpacity) {
+    int intOpacity = int(packedOpacity) / 2;
+    return vec2(float(intOpacity) / 127.0, mod(packedOpacity, 2.0));
+}
+
+// To minimize the number of attributes needed, we encode a 4-component
+// color into a pair of floats (i.e. a vec2) as follows:
+// [ floor(color.r * 255) * 256 + color.g * 255,
+//   floor(color.b * 255) * 256 + color.g * 255 ]
+vec4 decode_color(const vec2 encodedColor) {
+    return vec4(
+        unpack_float(encodedColor[0]) / 255.0,
+        unpack_float(encodedColor[1]) / 255.0
+    );
+}
+
+// Unpack a pair of paint values and interpolate between them.
+float unpack_mix_vec2(const vec2 packedValue, const float t) {
+    return mix(packedValue[0], packedValue[1], t);
+}
+
+// Unpack a pair of paint values and interpolate between them.
+vec4 unpack_mix_color(const vec4 packedColors, const float t) {
+    vec4 minColor = decode_color(vec2(packedColors[0], packedColors[1]));
+    vec4 maxColor = decode_color(vec2(packedColors[2], packedColors[3]));
+    return mix(minColor, maxColor, t);
+}
+
+// The offset depends on how many pixels are between the world origin and the edge of the tile:
+// vec2 offset = mod(pixel_coord, size)
+//
+// At high zoom levels there are a ton of pixels between the world origin and the edge of the tile.
+// The glsl spec only guarantees 16 bits of precision for highp floats. We need more than that.
+//
+// The pixel_coord is passed in as two 16 bit values:
+// pixel_coord_upper = floor(pixel_coord / 2^16)
+// pixel_coord_lower = mod(pixel_coord, 2^16)
+//
+// The offset is calculated in a series of steps that should preserve this precision:
+vec2 get_pattern_pos(const vec2 pixel_coord_upper, const vec2 pixel_coord_lower,
+    const vec2 pattern_size, const float tile_units_to_pixels, const vec2 pos) {
+
+    vec2 offset = mod(mod(mod(pixel_coord_upper, pattern_size) * 256.0, pattern_size) * 256.0 + pixel_coord_lower, pattern_size);
+    return (tile_units_to_pixels * pos + offset) / pattern_size;
+}

package/src/shaders/background.fragment.glsl

@@ -0,0 +1,10 @@
+uniform vec4 u_color;
+uniform float u_opacity;
+
+void main() {
+    gl_FragColor = u_color * u_opacity;
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/background.vertex.glsl

@@ -0,0 +1,7 @@
+attribute vec2 a_pos;
+
+uniform mat4 u_matrix;
+
+void main() {
+    gl_Position = u_matrix * vec4(a_pos, 0, 1);
+}

package/src/shaders/background_pattern.fragment.glsl

@@ -0,0 +1,28 @@
+uniform vec2 u_pattern_tl_a;
+uniform vec2 u_pattern_br_a;
+uniform vec2 u_pattern_tl_b;
+uniform vec2 u_pattern_br_b;
+uniform vec2 u_texsize;
+uniform float u_mix;
+uniform float u_opacity;
+
+uniform sampler2D u_image;
+
+varying vec2 v_pos_a;
+varying vec2 v_pos_b;
+
+void main() {
+    vec2 imagecoord = mod(v_pos_a, 1.0);
+    vec2 pos = mix(u_pattern_tl_a / u_texsize, u_pattern_br_a / u_texsize, imagecoord);
+    vec4 color1 = texture2D(u_image, pos);
+
+    vec2 imagecoord_b = mod(v_pos_b, 1.0);
+    vec2 pos2 = mix(u_pattern_tl_b / u_texsize, u_pattern_br_b / u_texsize, imagecoord_b);
+    vec4 color2 = texture2D(u_image, pos2);
+
+    gl_FragColor = mix(color1, color2, u_mix) * u_opacity;
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/background_pattern.vertex.glsl

@@ -0,0 +1,20 @@
+uniform mat4 u_matrix;
+uniform vec2 u_pattern_size_a;
+uniform vec2 u_pattern_size_b;
+uniform vec2 u_pixel_coord_upper;
+uniform vec2 u_pixel_coord_lower;
+uniform float u_scale_a;
+uniform float u_scale_b;
+uniform float u_tile_units_to_pixels;
+
+attribute vec2 a_pos;
+
+varying vec2 v_pos_a;
+varying vec2 v_pos_b;
+
+void main() {
+    gl_Position = u_matrix * vec4(a_pos, 0, 1);
+
+    v_pos_a = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_a * u_pattern_size_a, u_tile_units_to_pixels, a_pos);
+    v_pos_b = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_b * u_pattern_size_b, u_tile_units_to_pixels, a_pos);
+}

package/src/shaders/circle.fragment.glsl

@@ -0,0 +1,39 @@
+varying vec3 v_data;
+
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define mediump float radius
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define highp vec4 stroke_color
+#pragma mapbox: define mediump float stroke_width
+#pragma mapbox: define lowp float stroke_opacity
+
+void main() {
+    #pragma mapbox: initialize highp vec4 color
+    #pragma mapbox: initialize mediump float radius
+    #pragma mapbox: initialize lowp float blur
+    #pragma mapbox: initialize lowp float opacity
+    #pragma mapbox: initialize highp vec4 stroke_color
+    #pragma mapbox: initialize mediump float stroke_width
+    #pragma mapbox: initialize lowp float stroke_opacity
+
+    vec2 extrude = v_data.xy;
+    float extrude_length = length(extrude);
+
+    lowp float antialiasblur = v_data.z;
+    float antialiased_blur = -max(blur, antialiasblur);
+
+    float opacity_t = smoothstep(0.0, antialiased_blur, extrude_length - 1.0);
+
+    float color_t = stroke_width < 0.01 ? 0.0 : smoothstep(
+        antialiased_blur,
+        0.0,
+        extrude_length - radius / (radius + stroke_width)
+    );
+
+    gl_FragColor = opacity_t * mix(color * opacity, stroke_color * stroke_opacity, color_t);
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}

package/src/shaders/circle.vertex.glsl

@@ -0,0 +1,64 @@
+uniform mat4 u_matrix;
+uniform bool u_scale_with_map;
+uniform bool u_pitch_with_map;
+uniform vec2 u_extrude_scale;
+uniform lowp float u_device_pixel_ratio;
+uniform highp float u_camera_to_center_distance;
+
+attribute vec2 a_pos;
+
+varying vec3 v_data;
+
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define mediump float radius
+#pragma mapbox: define lowp float blur
+#pragma mapbox: define lowp float opacity
+#pragma mapbox: define highp vec4 stroke_color
+#pragma mapbox: define mediump float stroke_width
+#pragma mapbox: define lowp float stroke_opacity
+
+void main(void) {
+    #pragma mapbox: initialize highp vec4 color
+    #pragma mapbox: initialize mediump float radius
+    #pragma mapbox: initialize lowp float blur
+    #pragma mapbox: initialize lowp float opacity
+    #pragma mapbox: initialize highp vec4 stroke_color
+    #pragma mapbox: initialize mediump float stroke_width
+    #pragma mapbox: initialize lowp float stroke_opacity
+
+    // unencode the extrusion vector that we snuck into the a_pos vector
+    vec2 extrude = vec2(mod(a_pos, 2.0) * 2.0 - 1.0);
+
+    // multiply a_pos by 0.5, since we had it * 2 in order to sneak
+    // in extrusion data
+    vec2 circle_center = floor(a_pos * 0.5);
+    if (u_pitch_with_map) {
+        vec2 corner_position = circle_center;
+        if (u_scale_with_map) {
+            corner_position += extrude * (radius + stroke_width) * u_extrude_scale;
+        } else {
+            // Pitching the circle with the map effectively scales it with the map
+            // To counteract the effect for pitch-scale: viewport, we rescale the
+            // whole circle based on the pitch scaling effect at its central point
+            vec4 projected_center = u_matrix * vec4(circle_center, 0, 1);
+            corner_position += extrude * (radius + stroke_width) * u_extrude_scale * (projected_center.w / u_camera_to_center_distance);
+        }
+
+        gl_Position = u_matrix * vec4(corner_position, 0, 1);
+    } else {
+        gl_Position = u_matrix * vec4(circle_center, 0, 1);
+
+        if (u_scale_with_map) {
+            gl_Position.xy += extrude * (radius + stroke_width) * u_extrude_scale * u_camera_to_center_distance;
+        } else {
+            gl_Position.xy += extrude * (radius + stroke_width) * u_extrude_scale * gl_Position.w;
+        }
+    }
+
+    // This is a minimum blur distance that serves as a faux-antialiasing for
+    // the circle. since blur is a ratio of the circle's size and the intent is
+    // to keep the blur at roughly 1px, the two are inversely related.
+    lowp float antialiasblur = 1.0 / u_device_pixel_ratio / (radius + stroke_width);
+
+    v_data = vec3(extrude.x, extrude.y, antialiasblur);
+}

package/src/shaders/clipping_mask.fragment.glsl

@@ -0,0 +1,3 @@
+void main() {
+    gl_FragColor = vec4(1.0);
+}

package/src/shaders/clipping_mask.vertex.glsl

@@ -0,0 +1,7 @@
+attribute vec2 a_pos;
+
+uniform mat4 u_matrix;
+
+void main() {
+    gl_Position = u_matrix * vec4(a_pos, 0, 1);
+}

package/src/shaders/collision_box.fragment.glsl

@@ -0,0 +1,21 @@
+
+varying float v_placed;
+varying float v_notUsed;
+
+void main() {
+
+    float alpha = 0.5;
+
+    // Red = collision, hide label
+    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0) * alpha;
+
+    // Blue = no collision, label is showing
+    if (v_placed > 0.5) {
+        gl_FragColor = vec4(0.0, 0.0, 1.0, 0.5) * alpha;
+    }
+
+    if (v_notUsed > 0.5) {
+        // This box not used, fade it out
+        gl_FragColor *= .1;
+    }
+}

package/src/shaders/collision_box.vertex.glsl

@@ -0,0 +1,27 @@
+attribute vec2 a_pos;
+attribute vec2 a_anchor_pos;
+attribute vec2 a_extrude;
+attribute vec2 a_placed;
+attribute vec2 a_shift;
+
+uniform mat4 u_matrix;
+uniform vec2 u_extrude_scale;
+uniform float u_camera_to_center_distance;
+
+varying float v_placed;
+varying float v_notUsed;
+
+void main() {
+    vec4 projectedPoint = u_matrix * vec4(a_anchor_pos, 0, 1);
+    highp float camera_to_anchor_distance = projectedPoint.w;
+    highp float collision_perspective_ratio = clamp(
+        0.5 + 0.5 * (u_camera_to_center_distance / camera_to_anchor_distance),
+        0.0, // Prevents oversized near-field boxes in pitched/overzoomed tiles
+        4.0);
+
+    gl_Position = u_matrix * vec4(a_pos, 0.0, 1.0);
+    gl_Position.xy += (a_extrude + a_shift) * u_extrude_scale * gl_Position.w * collision_perspective_ratio;
+
+    v_placed = a_placed.x;
+    v_notUsed = a_placed.y;
+}

package/src/shaders/collision_circle.fragment.glsl

@@ -0,0 +1,17 @@
+varying float v_radius;
+varying vec2 v_extrude;
+varying float v_perspective_ratio;
+varying float v_collision;
+
+void main() {
+    float alpha = 0.5 * min(v_perspective_ratio, 1.0);
+    float stroke_radius = 0.9 * max(v_perspective_ratio, 1.0);
+
+    float distance_to_center = length(v_extrude);
+    float distance_to_edge = abs(distance_to_center - v_radius);
+    float opacity_t = smoothstep(-stroke_radius, 0.0, -distance_to_edge);
+
+    vec4 color = mix(vec4(0.0, 0.0, 1.0, 0.5), vec4(1.0, 0.0, 0.0, 1.0), v_collision);
+
+    gl_FragColor = color * alpha * opacity_t;
+}

package/src/shaders/collision_circle.vertex.glsl

@@ -0,0 +1,59 @@
+attribute vec2 a_pos;
+attribute float a_radius;
+attribute vec2 a_flags;
+
+uniform mat4 u_matrix;
+uniform mat4 u_inv_matrix;
+uniform vec2 u_viewport_size;
+uniform float u_camera_to_center_distance;
+
+varying float v_radius;
+varying vec2 v_extrude;
+varying float v_perspective_ratio;
+varying float v_collision;
+
+vec3 toTilePosition(vec2 screenPos) {
+    // Shoot a ray towards the ground to reconstruct the depth-value
+    vec4 rayStart = u_inv_matrix * vec4(screenPos, -1.0, 1.0);
+    vec4 rayEnd   = u_inv_matrix * vec4(screenPos,  1.0, 1.0);
+
+    rayStart.xyz /= rayStart.w;
+    rayEnd.xyz   /= rayEnd.w;
+
+    highp float t = (0.0 - rayStart.z) / (rayEnd.z - rayStart.z);
+    return mix(rayStart.xyz, rayEnd.xyz, t);
+}
+
+void main() {
+    vec2 quadCenterPos = a_pos;
+    float radius = a_radius;
+    float collision = a_flags.x;
+    float vertexIdx = a_flags.y;
+
+    vec2 quadVertexOffset = vec2(
+        mix(-1.0, 1.0, float(vertexIdx >= 2.0)),
+        mix(-1.0, 1.0, float(vertexIdx >= 1.0 && vertexIdx <= 2.0)));
+
+    vec2 quadVertexExtent = quadVertexOffset * radius;
+
+    // Screen position of the quad might have been computed with different camera parameters.
+    // Transform the point to a proper position on the current viewport
+    vec3 tilePos = toTilePosition(quadCenterPos);
+    vec4 clipPos = u_matrix * vec4(tilePos, 1.0);
+
+    highp float camera_to_anchor_distance = clipPos.w;
+    highp float collision_perspective_ratio = clamp(
+        0.5 + 0.5 * (u_camera_to_center_distance / camera_to_anchor_distance),
+        0.0, // Prevents oversized near-field circles in pitched/overzoomed tiles
+        4.0);
+
+    // Apply small padding for the anti-aliasing effect to fit the quad
+    // Note that v_radius and v_extrude are in screen coordinates already
+    float padding_factor = 1.2;
+    v_radius = radius;
+    v_extrude = quadVertexExtent * padding_factor;
+    v_perspective_ratio = collision_perspective_ratio;
+    v_collision = collision;
+
+    gl_Position = vec4(clipPos.xyz / clipPos.w, 1.0) + vec4(quadVertexExtent * padding_factor / u_viewport_size * 2.0, 0.0, 0.0);
+}

package/src/shaders/debug.fragment.glsl

@@ -0,0 +1,9 @@
+uniform highp vec4 u_color;
+uniform sampler2D u_overlay;
+
+varying vec2 v_uv;
+
+void main() {
+    vec4 overlay_color = texture2D(u_overlay, v_uv);
+    gl_FragColor = mix(u_color, overlay_color, overlay_color.a);
+}

package/src/shaders/debug.vertex.glsl

@@ -0,0 +1,12 @@
+attribute vec2 a_pos;
+varying vec2 v_uv;
+
+uniform mat4 u_matrix;
+uniform float u_overlay_scale;
+
+void main() {
+    // This vertex shader expects a EXTENT x EXTENT quad,
+    // The UV co-ordinates for the overlay texture can be calculated using that knowledge
+    v_uv = a_pos / 8192.0;
+    gl_Position = u_matrix * vec4(a_pos * u_overlay_scale, 0, 1);
+}

package/src/shaders/encode_attribute.js

@@ -0,0 +1,17 @@
+// @flow
+
+import {clamp} from '../util/util';
+
+/**
+ * Packs two numbers, interpreted as 8-bit unsigned integers, into a single
+ * float.  Unpack them in the shader using the `unpack_float()` function,
+ * defined in _prelude.vertex.glsl
+ *
+ * @private
+ */
+export function packUint8ToFloat(a: number, b: number) {
+    // coerce a and b to 8-bit ints
+    a = clamp(Math.floor(a), 0, 255);
+    b = clamp(Math.floor(b), 0, 255);
+    return 256 * a + b;
+}

package/src/shaders/fill.fragment.glsl

@@ -0,0 +1,13 @@
+#pragma mapbox: define highp vec4 color
+#pragma mapbox: define lowp float opacity
+
+void main() {
+    #pragma mapbox: initialize highp vec4 color
+    #pragma mapbox: initialize lowp float opacity
+
+    gl_FragColor = color * opacity;
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}