@mapwhit/tilerenderer 0.47.1

package/src/render/vertex_array_object.js

@@ -0,0 +1,155 @@
+const assert = require('assert');
+
+class VertexArrayObject {
+  constructor() {
+    this.boundProgram = null;
+    this.boundLayoutVertexBuffer = null;
+    this.boundPaintVertexBuffers = [];
+    this.boundIndexBuffer = null;
+    this.boundVertexOffset = null;
+    this.boundDynamicVertexBuffer = null;
+    this.vao = null;
+  }
+
+  bind(
+    context,
+    program,
+    layoutVertexBuffer,
+    paintVertexBuffers,
+    indexBuffer,
+    vertexOffset,
+    dynamicVertexBuffer,
+    dynamicVertexBuffer2
+  ) {
+    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?.dynamicDraw) {
+        indexBuffer.bind();
+      }
+
+      if (dynamicVertexBuffer2) {
+        dynamicVertexBuffer2.bind();
+      }
+    }
+  }
+
+  freshBind(
+    program,
+    layoutVertexBuffer,
+    paintVertexBuffers,
+    indexBuffer,
+    vertexOffset,
+    dynamicVertexBuffer,
+    dynamicVertexBuffer2
+  ) {
+    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;
+    }
+  }
+}
+
+module.exports = 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
+
+## Util
+
+The `util.glsl` file is 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 @@
+#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
+
+varying vec3 v_data;
+
+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,63 @@
+uniform mat4 u_matrix;
+uniform bool u_scale_with_map;
+uniform bool u_pitch_with_map;
+uniform vec2 u_extrude_scale;
+uniform highp float u_camera_to_center_distance;
+
+attribute vec2 a_pos;
+
+#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
+
+varying vec3 v_data;
+
+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 / 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,26 @@
+attribute vec2 a_pos;
+attribute vec2 a_anchor_pos;
+attribute vec2 a_extrude;
+attribute vec2 a_placed;
+
+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 * 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,34 @@
+uniform float u_overscale_factor;
+
+varying float v_placed;
+varying float v_notUsed;
+varying float v_radius;
+varying vec2 v_extrude;
+varying vec2 v_extrude_scale;
+
+void main() {
+    float alpha = 0.5;
+
+    // Red = collision, hide label
+    vec4 color = vec4(1.0, 0.0, 0.0, 1.0) * alpha;
+
+    // Blue = no collision, label is showing
+    if (v_placed > 0.5) {
+        color = vec4(0.0, 0.0, 1.0, 0.5) * alpha;
+    }
+
+    if (v_notUsed > 0.5) {
+        // This box not used, fade it out
+        color *= .2;
+    }
+
+    float extrude_scale_length = length(v_extrude_scale);
+    float extrude_length = length(v_extrude) * extrude_scale_length;
+    float stroke_width = 15.0 * extrude_scale_length / u_overscale_factor;
+    float radius = v_radius * extrude_scale_length;
+
+    float distance_to_edge = abs(extrude_length - radius);
+    float opacity_t = smoothstep(-stroke_width, 0.0, -distance_to_edge);
+
+    gl_FragColor = opacity_t * color;
+}

package/src/shaders/collision_circle.vertex.glsl

@@ -0,0 +1,36 @@
+attribute vec2 a_pos;
+attribute vec2 a_anchor_pos;
+attribute vec2 a_extrude;
+attribute vec2 a_placed;
+
+uniform mat4 u_matrix;
+uniform vec2 u_extrude_scale;
+uniform float u_camera_to_center_distance;
+
+varying float v_placed;
+varying float v_notUsed;
+varying float v_radius;
+
+varying vec2 v_extrude;
+varying vec2 v_extrude_scale;
+
+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 circles in pitched/overzoomed tiles
+        4.0);
+
+    gl_Position = u_matrix * vec4(a_pos, 0.0, 1.0);
+
+    highp float padding_factor = 1.2; // Pad the vertices slightly to make room for anti-alias blur
+    gl_Position.xy += a_extrude * u_extrude_scale * padding_factor * gl_Position.w * collision_perspective_ratio;
+
+    v_placed = a_placed.x;
+    v_notUsed = a_placed.y;
+    v_radius = abs(a_extrude.y); // We don't pitch the circles, so both units of the extrusion vector are equal in magnitude to the radius
+
+    v_extrude = a_extrude * padding_factor;
+    v_extrude_scale = u_extrude_scale * u_camera_to_center_distance * collision_perspective_ratio;
+}

package/src/shaders/debug.fragment.glsl

@@ -0,0 +1,5 @@
+uniform highp vec4 u_color;
+
+void main() {
+    gl_FragColor = u_color;
+}

package/src/shaders/debug.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/encode_attribute.js

@@ -0,0 +1,19 @@
+const { clamp } = require('../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
+ */
+function pack(a, b) {
+  // 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;
+}
+
+module.exports = {
+  packUint8ToFloat: pack
+};

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
+}

package/src/shaders/fill.vertex.glsl

@@ -0,0 +1,13 @@
+attribute vec2 a_pos;
+
+uniform mat4 u_matrix;
+
+#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_Position = u_matrix * vec4(a_pos, 0, 1);
+}

package/src/shaders/fill_extrusion.fragment.glsl

@@ -0,0 +1,16 @@
+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
+
+    gl_FragColor = v_color;
+
+#ifdef OVERDRAW_INSPECTOR
+    gl_FragColor = vec4(1.0);
+#endif
+}