@scoova/mgl 1.0.0

package/src/shaders/_prelude.vertex.glsl

@@ -0,0 +1,148 @@
+#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 ins 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;
+}
+
+// logic for terrain 3d
+
+#ifdef TERRAIN3D
+uniform sampler2D u_terrain;
+uniform float u_terrain_dim;
+uniform mat4 u_terrain_matrix;
+uniform vec4 u_terrain_unpack;
+uniform float u_terrain_exaggeration;
+uniform highp sampler2D u_depth;
+#endif
+
+// methods for pack/unpack depth value to texture rgba
+// https://stackoverflow.com/questions/34963366/encode-floating-point-data-in-a-rgba-texture
+const highp vec4 bitSh = vec4(256. * 256. * 256., 256. * 256., 256., 1.);
+const highp vec4 bitShifts = vec4(1.) / bitSh;
+
+highp float unpack(highp vec4 color) {
+   return dot(color , bitShifts);
+}
+
+// calculate the opacity behind terrain, returns a value between 0 and 1.
+highp float depthOpacity(vec3 frag) {
+    #ifdef TERRAIN3D
+        // create the delta between frag.z + terrain.z.
+        highp float d = unpack(texture(u_depth, frag.xy * 0.5 + 0.5)) + 0.0001 - frag.z;
+        // visibility range is between 0 and 0.002. 0 is visible, 0.002 is fully invisible.
+        return 1.0 - max(0.0, min(1.0, -d * 500.0));
+    #else
+        return 1.0;
+    #endif
+}
+
+// calculate the visibility of a coordinate in terrain and return an opacity value.
+// if a coordinate is behind the terrain reduce its opacity
+float calculate_visibility(vec4 pos) {
+    #ifdef TERRAIN3D
+        vec3 frag = pos.xyz / pos.w;
+        // check if coordinate is fully visible
+        highp float d = depthOpacity(frag);
+        if (d > 0.95) return 1.0;
+        // if not, go some pixel above and check it this point is visible
+        return (d + depthOpacity(frag + vec3(0.0, 0.01, 0.0))) / 2.0;
+    #else
+        return 1.0;
+    #endif
+}
+
+// grab an elevation value from a raster-dem texture
+float ele(vec2 pos) {
+    #ifdef TERRAIN3D
+        vec4 rgb = (texture(u_terrain, pos) * 255.0) * u_terrain_unpack;
+        return rgb.r + rgb.g + rgb.b - u_terrain_unpack.a;
+    #else
+        return 0.0;
+    #endif
+}
+
+// calculate the elevation with linear interpolation for  a coordinate
+float get_elevation(vec2 pos) {
+    #ifdef TERRAIN3D
+        vec2 coord = (u_terrain_matrix * vec4(pos, 0.0, 1.0)).xy * u_terrain_dim + 1.0;
+        vec2 f = fract(coord);
+        vec2 c = (floor(coord) + 0.5) / (u_terrain_dim + 2.0); // get the pixel center
+        float d = 1.0 / (u_terrain_dim + 2.0);
+        float tl = ele(c);
+        float tr = ele(c + vec2(d, 0.0));
+        float bl = ele(c + vec2(0.0, d));
+        float br = ele(c + vec2(d, d));
+        float elevation = mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);
+        return elevation * u_terrain_exaggeration;
+    #else
+        return 0.0;
+    #endif
+}

package/src/shaders/_prelude.vertex.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default '#ifdef GL_ES\nprecision highp float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\nvec2 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));}vec4 decode_color(const vec2 encodedColor) {return vec4(unpack_float(encodedColor[0])/255.0,unpack_float(encodedColor[1])/255.0\n);}float unpack_mix_vec2(const vec2 packedValue,const float t) {return mix(packedValue[0],packedValue[1],t);}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);}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;}\n#ifdef TERRAIN3D\nuniform sampler2D u_terrain;uniform float u_terrain_dim;uniform mat4 u_terrain_matrix;uniform vec4 u_terrain_unpack;uniform float u_terrain_exaggeration;uniform highp sampler2D u_depth;\n#endif\nconst highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitShifts=vec4(1.)/bitSh;highp float unpack(highp vec4 color) {return dot(color,bitShifts);}highp float depthOpacity(vec3 frag) {\n#ifdef TERRAIN3D\nhighp float d=unpack(texture2D(u_depth,frag.xy*0.5+0.5))+0.0001-frag.z;return 1.0-max(0.0,min(1.0,-d*500.0));\n#else\nreturn 1.0;\n#endif\n}float calculate_visibility(vec4 pos) {\n#ifdef TERRAIN3D\nvec3 frag=pos.xyz/pos.w;highp float d=depthOpacity(frag);if (d > 0.95) return 1.0;return (d+depthOpacity(frag+vec3(0.0,0.01,0.0)))/2.0;\n#else\nreturn 1.0;\n#endif\n}float ele(vec2 pos) {\n#ifdef TERRAIN3D\nvec4 rgb=(texture2D(u_terrain,pos)*255.0)*u_terrain_unpack;return rgb.r+rgb.g+rgb.b-u_terrain_unpack.a;\n#else\nreturn 0.0;\n#endif\n}float get_elevation(vec2 pos) {\n#ifdef TERRAIN3D\nvec2 coord=(u_terrain_matrix*vec4(pos,0.0,1.0)).xy*u_terrain_dim+1.0;vec2 f=fract(coord);vec2 c=(floor(coord)+0.5)/(u_terrain_dim+2.0);float d=1.0/(u_terrain_dim+2.0);float tl=ele(c);float tr=ele(c+vec2(d,0.0));float bl=ele(c+vec2(0.0,d));float br=ele(c+vec2(d,d));float elevation=mix(mix(tl,tr,f.x),mix(bl,br,f.x),f.y);return elevation*u_terrain_exaggeration;\n#else\nreturn 0.0;\n#endif\n}';

package/src/shaders/background.fragment.glsl

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

package/src/shaders/background.fragment.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default 'uniform vec4 u_color;uniform float u_opacity;void main() {gl_FragColor=u_color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}';

package/src/shaders/background.vertex.glsl

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

package/src/shaders/background.vertex.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default '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;
+
+in vec2 v_pos_a;
+in 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 = texture(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 = texture(u_image, pos2);
+
+    fragColor = mix(color1, color2, u_mix) * u_opacity;
+
+#ifdef OVERDRAW_INSPECTOR
+    fragColor = vec4(1.0);
+#endif
+}

package/src/shaders/background_pattern.fragment.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default '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;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}';

package/src/shaders/background_pattern.vertex.glsl

@@ -0,0 +1,19 @@
+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;
+
+in vec2 a_pos;
+out vec2 v_pos_a;
+out 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/background_pattern.vertex.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default '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,34 @@
+in vec3 v_data;
+in float v_visibility;
+
+#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);
+    float antialiased_blur = v_data.z;
+
+    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));
+
+    fragColor = v_visibility * opacity_t * mix(color * opacity, stroke_color * stroke_opacity, color_t);
+
+#ifdef OVERDRAW_INSPECTOR
+    fragColor = vec4(1.0);
+#endif
+}

package/src/shaders/circle.fragment.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default 'varying vec3 v_data;varying float v_visibility;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define mediump float radius\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define highp vec4 stroke_color\n#pragma mapbox: define mediump float stroke_width\n#pragma mapbox: define lowp float stroke_opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize mediump float radius\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize highp vec4 stroke_color\n#pragma mapbox: initialize mediump float stroke_width\n#pragma mapbox: initialize lowp float stroke_opacity\nvec2 extrude=v_data.xy;float extrude_length=length(extrude);float antialiased_blur=v_data.z;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=v_visibility*opacity_t*mix(color*opacity,stroke_color*stroke_opacity,color_t);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}';

package/src/shaders/circle.vertex.glsl

@@ -0,0 +1,68 @@
+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;
+
+in vec2 a_pos;
+
+out vec3 v_data;
+out float v_visibility;
+
+#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
+
+    // decode 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);
+    float ele = get_elevation(circle_center);
+    v_visibility = calculate_visibility(u_matrix * vec4(circle_center, ele, 1.0));
+
+    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, ele, 1);
+    } else {
+        gl_Position = u_matrix * vec4(circle_center, ele, 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.
+    float antialiasblur = -max(1.0 / u_device_pixel_ratio / (radius + stroke_width), blur);
+
+    v_data = vec3(extrude.x, extrude.y, antialiasblur);
+}

package/src/shaders/circle.vertex.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default '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;varying float v_visibility;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define mediump float radius\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define highp vec4 stroke_color\n#pragma mapbox: define mediump float stroke_width\n#pragma mapbox: define lowp float stroke_opacity\nvoid main(void) {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize mediump float radius\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize highp vec4 stroke_color\n#pragma mapbox: initialize mediump float stroke_width\n#pragma mapbox: initialize lowp float stroke_opacity\nvec2 extrude=vec2(mod(a_pos,2.0)*2.0-1.0);vec2 circle_center=floor(a_pos*0.5);float ele=get_elevation(circle_center);v_visibility=calculate_visibility(u_matrix*vec4(circle_center,ele,1.0));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 {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,ele,1);} else {gl_Position=u_matrix*vec4(circle_center,ele,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;}}float antialiasblur=-max(1.0/u_device_pixel_ratio/(radius+stroke_width),blur);v_data=vec3(extrude.x,extrude.y,antialiasblur);}';

package/src/shaders/clipping_mask.fragment.glsl

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

package/src/shaders/clipping_mask.fragment.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default 'void main() {gl_FragColor=vec4(1.0);}';

package/src/shaders/clipping_mask.vertex.glsl

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

package/src/shaders/clipping_mask.vertex.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default '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,20 @@
+in float v_placed;
+in float v_notUsed;
+
+void main() {
+
+    float alpha = 0.5;
+
+    // Red = collision, hide label
+    fragColor = vec4(1.0, 0.0, 0.0, 1.0) * alpha;
+
+    // Blue = no collision, label is showing
+    if (v_placed > 0.5) {
+        fragColor = vec4(0.0, 0.0, 1.0, 0.5) * alpha;
+    }
+
+    if (v_notUsed > 0.5) {
+        // This box not used, fade it out
+        fragColor *= .1;
+    }
+}

package/src/shaders/collision_box.fragment.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default 'varying float v_placed;varying float v_notUsed;void main() {float alpha=0.5;gl_FragColor=vec4(1.0,0.0,0.0,1.0)*alpha;if (v_placed > 0.5) {gl_FragColor=vec4(0.0,0.0,1.0,0.5)*alpha;}if (v_notUsed > 0.5) {gl_FragColor*=.1;}}';

package/src/shaders/collision_box.vertex.glsl

@@ -0,0 +1,27 @@
+in vec2 a_anchor_pos;
+in vec2 a_placed;
+in vec2 a_box_real;
+
+uniform mat4 u_matrix;
+uniform vec2 u_pixel_extrude_scale;
+
+out float v_placed;
+out float v_notUsed;
+
+vec4 projectTileWithElevation(vec2 posInTile, float elevation) {
+    return u_matrix * vec4(posInTile, elevation, 1.0);
+}
+
+void main() {
+    gl_Position = projectTileWithElevation(a_anchor_pos, get_elevation(a_anchor_pos));
+    gl_Position.xy = ((a_box_real + 0.5) * u_pixel_extrude_scale * 2.0 - 1.0) * vec2(1.0, -1.0) * gl_Position.w;
+    if (gl_Position.z / gl_Position.w < 1.1) {
+        // Globe projection would set Z beyond visible range if the anchor point gets hidden behind the planet's horizon.
+        // We force Z to a visible value, even for anchors that are slightly behind the horizon.
+        // Anchors that are too far beyond the horizon are still hidden.
+        gl_Position.z = 0.5;
+    }
+
+    v_placed = a_placed.x;
+    v_notUsed = a_placed.y;
+}

package/src/shaders/collision_box.vertex.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default 'attribute vec2 a_anchor_pos;attribute vec2 a_placed;attribute vec2 a_box_real;uniform mat4 u_matrix;uniform vec2 u_pixel_extrude_scale;varying float v_placed;varying float v_notUsed;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}void main() {gl_Position=projectTileWithElevation(a_anchor_pos,get_elevation(a_anchor_pos));gl_Position.xy=((a_box_real+0.5)*u_pixel_extrude_scale*2.0-1.0)*vec2(1.0,-1.0)*gl_Position.w;if (gl_Position.z/gl_Position.w < 1.1) {gl_Position.z=0.5;}v_placed=a_placed.x;v_notUsed=a_placed.y;}';

package/src/shaders/collision_circle.fragment.glsl

@@ -0,0 +1,17 @@
+in float v_radius;
+in vec2 v_extrude;
+in float v_perspective_ratio;
+in 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);
+
+    fragColor = color * alpha * opacity_t;
+}

package/src/shaders/collision_circle.fragment.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default '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 @@
+in vec2 a_pos;
+in float a_radius;
+in vec2 a_flags;
+
+uniform mat4 u_matrix;
+uniform mat4 u_inv_matrix;
+uniform vec2 u_viewport_size;
+uniform float u_camera_to_center_distance;
+
+out float v_radius;
+out vec2 v_extrude;
+out float v_perspective_ratio;
+out 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/collision_circle.vertex.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default '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) {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;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,4.0);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;
+
+in vec2 v_uv;
+
+void main() {
+    vec4 overlay_color = texture(u_overlay, v_uv);
+    fragColor = mix(u_color, overlay_color, overlay_color.a);
+}

package/src/shaders/debug.fragment.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default '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 @@
+in vec2 a_pos;
+out 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, get_elevation(a_pos), 1);
+}

package/src/shaders/debug.vertex.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default 'attribute vec2 a_pos;varying vec2 v_uv;uniform mat4 u_matrix;uniform float u_overlay_scale;void main() {v_uv=a_pos/8192.0;gl_Position=u_matrix*vec4(a_pos*u_overlay_scale,get_elevation(a_pos),1);}';

package/src/shaders/encode_attribute.test.ts

@@ -0,0 +1,11 @@
+import {packUint8ToFloat} from './encode_attribute';
+
+test('packUint8ToFloat', () => {
+    expect(packUint8ToFloat(0, 0)).toBe(0);
+    expect(packUint8ToFloat(255, 255)).toBe(65535);
+    expect(packUint8ToFloat(123, 45)).toBe(31533);
+
+    expect(packUint8ToFloat(-1, -1)).toBe(0);
+    expect(packUint8ToFloat(256, 256)).toBe(65535);
+
+});

package/src/shaders/encode_attribute.ts

@@ -0,0 +1,13 @@
+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
+ */
+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
+
+    fragColor = color * opacity;
+
+#ifdef OVERDRAW_INSPECTOR
+    fragColor = vec4(1.0);
+#endif
+}

package/src/shaders/fill.fragment.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default '#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float opacity\ngl_FragColor=color*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}';

package/src/shaders/fill.vertex.glsl

@@ -0,0 +1,13 @@
+in 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.vertex.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default 'attribute vec2 a_pos;uniform mat4 u_matrix;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float opacity\ngl_Position=u_matrix*vec4(a_pos,0,1);}';

package/src/shaders/fill_extrusion.fragment.glsl

@@ -0,0 +1,9 @@
+in vec4 v_color;
+
+void main() {
+    fragColor = v_color;
+
+#ifdef OVERDRAW_INSPECTOR
+    fragColor = vec4(1.0);
+#endif
+}

package/src/shaders/fill_extrusion.fragment.glsl.g.ts

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default 'varying vec4 v_color;void main() {gl_FragColor=v_color;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}';