@scoova/mgl 1.0.0

package/src/shaders/line_sdf.fragment.glsl

@@ -0,0 +1,45 @@
+
+uniform lowp float u_device_pixel_ratio;
+uniform sampler2D u_image;
+uniform float u_sdfgamma;
+uniform float u_mix;
+
+in vec2 v_normal;
+in vec2 v_width2;
+in vec2 v_tex_a;
+in vec2 v_tex_b;
+in 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 / u_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 = texture(u_image, v_tex_a).a;
+    float sdfdist_b = texture(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);
+
+    fragColor = color * (alpha * opacity);
+
+#ifdef OVERDRAW_INSPECTOR
+    fragColor = vec4(1.0);
+#endif
+}

package/src/shaders/line_sdf.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 lowp float u_device_pixel_ratio;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;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_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);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}';

package/src/shaders/line_sdf.vertex.glsl

@@ -0,0 +1,101 @@
+// 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
+
+in vec2 a_pos_normal;
+in vec4 a_data;
+
+uniform mat4 u_matrix;
+uniform mediump float u_ratio;
+uniform lowp float u_device_pixel_ratio;
+uniform vec2 u_patternscale_a;
+uniform float u_tex_y_a;
+uniform vec2 u_patternscale_b;
+uniform float u_tex_y_b;
+uniform vec2 u_units_to_pixels;
+
+out vec2 v_normal;
+out vec2 v_width2;
+out vec2 v_tex_a;
+out vec2 v_tex_b;
+out 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 gapwidth
+#pragma mapbox: define lowp float offset
+#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 gapwidth
+    #pragma mapbox: initialize lowp float offset
+    #pragma mapbox: initialize mediump float width
+    #pragma mapbox: initialize lowp float floorwidth
+
+    // the distance over which the line edge fades out.
+    // Retina devices need a smaller distance to avoid aliasing.
+    float ANTIALIASING = 1.0 / u_device_pixel_ratio / 2.0;
+
+    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;
+
+    vec2 pos = floor(a_pos_normal * 0.5);
+
+    // 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
+    // We store these in the least significant bit of a_pos_normal
+    mediump vec2 normal = a_pos_normal - 2.0 * pos;
+    normal.y = normal.y * 2.0 - 1.0;
+    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
+    #ifdef TERRAIN3D
+        v_gamma_scale = 1.0; // not needed, because this is done automatically via the mesh
+    #else
+        float extrude_length_without_perspective = length(dist);
+        float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_units_to_pixels);
+        v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;
+    #endif
+
+    v_tex_a = vec2(a_linesofar * u_patternscale_a.x / floorwidth, normal.y * u_patternscale_a.y + u_tex_y_a);
+    v_tex_b = vec2(a_linesofar * u_patternscale_b.x / floorwidth, normal.y * u_patternscale_b.y + u_tex_y_b);
+    v_width2 = vec2(outset, inset);
+}

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

@@ -0,0 +1,2 @@
+// This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
+export default '\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_patternscale_a;uniform float u_tex_y_a;uniform vec2 u_patternscale_b;uniform float u_tex_y_b;uniform vec2 u_units_to_pixels;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;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;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;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);mediump vec2 dist=outset*a_extrude*scale;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;\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_tex_a=vec2(a_linesofar*u_patternscale_a.x/floorwidth,normal.y*u_patternscale_a.y+u_tex_y_a);v_tex_b=vec2(a_linesofar*u_patternscale_b.x/floorwidth,normal.y*u_patternscale_b.y+u_tex_y_b);v_width2=vec2(outset,inset);}';

package/src/shaders/raster.fragment.glsl

@@ -0,0 +1,53 @@
+uniform float u_fade_t;
+uniform float u_opacity;
+uniform sampler2D u_image0;
+uniform sampler2D u_image1;
+
+in vec2 v_pos0;
+in vec2 v_pos1;
+
+uniform float u_brightness_low;
+uniform float u_brightness_high;
+
+uniform float u_saturation_factor;
+uniform float u_contrast_factor;
+uniform vec3 u_spin_weights;
+
+void main() {
+
+    // read and cross-fade colors from the main and parent tiles
+    vec4 color0 = texture(u_image0, v_pos0);
+    vec4 color1 = texture(u_image1, v_pos1);
+    if (color0.a > 0.0) {
+        color0.rgb = color0.rgb / color0.a;
+    }
+    if (color1.a > 0.0) {
+        color1.rgb = color1.rgb / color1.a;
+    }
+    vec4 color = mix(color0, color1, u_fade_t);
+    color.a *= u_opacity;
+    vec3 rgb = color.rgb;
+
+    // spin
+    rgb = vec3(
+        dot(rgb, u_spin_weights.xyz),
+        dot(rgb, u_spin_weights.zxy),
+        dot(rgb, u_spin_weights.yzx));
+
+    // saturation
+    float average = (color.r + color.g + color.b) / 3.0;
+    rgb += (average - rgb) * u_saturation_factor;
+
+    // contrast
+    rgb = (rgb - 0.5) * u_contrast_factor + 0.5;
+
+    // brightness
+    vec3 u_high_vec = vec3(u_brightness_low, u_brightness_low, u_brightness_low);
+    vec3 u_low_vec = vec3(u_brightness_high, u_brightness_high, u_brightness_high);
+
+    fragColor = vec4(mix(u_high_vec, u_low_vec, rgb) * color.a, color.a);
+
+#ifdef OVERDRAW_INSPECTOR
+    fragColor = vec4(1.0);
+#endif
+}

package/src/shaders/raster.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 float u_fade_t;uniform float u_opacity;uniform sampler2D u_image0;uniform sampler2D u_image1;varying vec2 v_pos0;varying vec2 v_pos1;uniform float u_brightness_low;uniform float u_brightness_high;uniform float u_saturation_factor;uniform float u_contrast_factor;uniform vec3 u_spin_weights;void main() {vec4 color0=texture2D(u_image0,v_pos0);vec4 color1=texture2D(u_image1,v_pos1);if (color0.a > 0.0) {color0.rgb=color0.rgb/color0.a;}if (color1.a > 0.0) {color1.rgb=color1.rgb/color1.a;}vec4 color=mix(color0,color1,u_fade_t);color.a*=u_opacity;vec3 rgb=color.rgb;rgb=vec3(dot(rgb,u_spin_weights.xyz),dot(rgb,u_spin_weights.zxy),dot(rgb,u_spin_weights.yzx));float average=(color.r+color.g+color.b)/3.0;rgb+=(average-rgb)*u_saturation_factor;rgb=(rgb-0.5)*u_contrast_factor+0.5;vec3 u_high_vec=vec3(u_brightness_low,u_brightness_low,u_brightness_low);vec3 u_low_vec=vec3(u_brightness_high,u_brightness_high,u_brightness_high);gl_FragColor=vec4(mix(u_high_vec,u_low_vec,rgb)*color.a,color.a);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}';

package/src/shaders/raster.vertex.glsl

@@ -0,0 +1,21 @@
+uniform mat4 u_matrix;
+uniform vec2 u_tl_parent;
+uniform float u_scale_parent;
+uniform float u_buffer_scale;
+
+in vec2 a_pos;
+in vec2 a_texture_pos;
+
+out vec2 v_pos0;
+out vec2 v_pos1;
+
+void main() {
+    gl_Position = u_matrix * vec4(a_pos, 0, 1);
+    // We are using Int16 for texture position coordinates to give us enough precision for
+    // fractional coordinates. We use 8192 to scale the texture coordinates in the buffer
+    // as an arbitrarily high number to preserve adequate precision when rendering.
+    // This is also the same value as the EXTENT we are using for our tile buffer pos coordinates,
+    // so math for modifying either is consistent.
+    v_pos0 = (((a_texture_pos / 8192.0) - 0.5) / u_buffer_scale ) + 0.5;
+    v_pos1 = (v_pos0 * u_scale_parent) + u_tl_parent;
+}

package/src/shaders/raster.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_tl_parent;uniform float u_scale_parent;uniform float u_buffer_scale;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos0;varying vec2 v_pos1;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos0=(((a_texture_pos/8192.0)-0.5)/u_buffer_scale )+0.5;v_pos1=(v_pos0*u_scale_parent)+u_tl_parent;}';

package/src/shaders/shaders.ts

@@ -0,0 +1,197 @@
+
+// Disable Flow annotations here because Flow doesn't support importing GLSL files
+
+import preludeFrag from './_prelude.fragment.glsl.g';
+import preludeVert from './_prelude.vertex.glsl.g';
+import backgroundFrag from './background.fragment.glsl.g';
+import backgroundVert from './background.vertex.glsl.g';
+import backgroundPatternFrag from './background_pattern.fragment.glsl.g';
+import backgroundPatternVert from './background_pattern.vertex.glsl.g';
+import circleFrag from './circle.fragment.glsl.g';
+import circleVert from './circle.vertex.glsl.g';
+import clippingMaskFrag from './clipping_mask.fragment.glsl.g';
+import clippingMaskVert from './clipping_mask.vertex.glsl.g';
+import heatmapFrag from './heatmap.fragment.glsl.g';
+import heatmapVert from './heatmap.vertex.glsl.g';
+import heatmapTextureFrag from './heatmap_texture.fragment.glsl.g';
+import heatmapTextureVert from './heatmap_texture.vertex.glsl.g';
+import collisionBoxFrag from './collision_box.fragment.glsl.g';
+import collisionBoxVert from './collision_box.vertex.glsl.g';
+import collisionCircleFrag from './collision_circle.fragment.glsl.g';
+import collisionCircleVert from './collision_circle.vertex.glsl.g';
+import debugFrag from './debug.fragment.glsl.g';
+import debugVert from './debug.vertex.glsl.g';
+import fillFrag from './fill.fragment.glsl.g';
+import fillVert from './fill.vertex.glsl.g';
+import fillOutlineFrag from './fill_outline.fragment.glsl.g';
+import fillOutlineVert from './fill_outline.vertex.glsl.g';
+import fillOutlinePatternFrag from './fill_outline_pattern.fragment.glsl.g';
+import fillOutlinePatternVert from './fill_outline_pattern.vertex.glsl.g';
+import fillPatternFrag from './fill_pattern.fragment.glsl.g';
+import fillPatternVert from './fill_pattern.vertex.glsl.g';
+import fillExtrusionFrag from './fill_extrusion.fragment.glsl.g';
+import fillExtrusionVert from './fill_extrusion.vertex.glsl.g';
+import fillExtrusionPatternFrag from './fill_extrusion_pattern.fragment.glsl.g';
+import fillExtrusionPatternVert from './fill_extrusion_pattern.vertex.glsl.g';
+import hillshadePrepareFrag from './hillshade_prepare.fragment.glsl.g';
+import hillshadePrepareVert from './hillshade_prepare.vertex.glsl.g';
+import hillshadeFrag from './hillshade.fragment.glsl.g';
+import hillshadeVert from './hillshade.vertex.glsl.g';
+import lineFrag from './line.fragment.glsl.g';
+import lineVert from './line.vertex.glsl.g';
+import lineGradientFrag from './line_gradient.fragment.glsl.g';
+import lineGradientVert from './line_gradient.vertex.glsl.g';
+import linePatternFrag from './line_pattern.fragment.glsl.g';
+import linePatternVert from './line_pattern.vertex.glsl.g';
+import lineSDFFrag from './line_sdf.fragment.glsl.g';
+import lineSDFVert from './line_sdf.vertex.glsl.g';
+import rasterFrag from './raster.fragment.glsl.g';
+import rasterVert from './raster.vertex.glsl.g';
+import symbolIconFrag from './symbol_icon.fragment.glsl.g';
+import symbolIconVert from './symbol_icon.vertex.glsl.g';
+import symbolSDFFrag from './symbol_sdf.fragment.glsl.g';
+import symbolSDFVert from './symbol_sdf.vertex.glsl.g';
+import symbolTextAndIconFrag from './symbol_text_and_icon.fragment.glsl.g';
+import symbolTextAndIconVert from './symbol_text_and_icon.vertex.glsl.g';
+import terrainDepthFrag from './terrain_depth.fragment.glsl.g';
+import terrainCoordsFrag from './terrain_coords.fragment.glsl.g';
+import terrainFrag from './terrain.fragment.glsl.g';
+import terrainDepthVert from './terrain_depth.vertex.glsl.g';
+import terrainCoordsVert from './terrain_coords.vertex.glsl.g';
+import terrainVert from './terrain.vertex.glsl.g';
+import skyFrag from './sky.fragment.glsl.g';
+import skyVert from './sky.vertex.glsl.g';
+
+export const shaders = {
+    prelude: compile(preludeFrag, preludeVert),
+    background: compile(backgroundFrag, backgroundVert),
+    backgroundPattern: compile(backgroundPatternFrag, backgroundPatternVert),
+    circle: compile(circleFrag, circleVert),
+    clippingMask: compile(clippingMaskFrag, clippingMaskVert),
+    heatmap: compile(heatmapFrag, heatmapVert),
+    heatmapTexture: compile(heatmapTextureFrag, heatmapTextureVert),
+    collisionBox: compile(collisionBoxFrag, collisionBoxVert),
+    collisionCircle: compile(collisionCircleFrag, collisionCircleVert),
+    debug: compile(debugFrag, debugVert),
+    fill: compile(fillFrag, fillVert),
+    fillOutline: compile(fillOutlineFrag, fillOutlineVert),
+    fillOutlinePattern: compile(fillOutlinePatternFrag, fillOutlinePatternVert),
+    fillPattern: compile(fillPatternFrag, fillPatternVert),
+    fillExtrusion: compile(fillExtrusionFrag, fillExtrusionVert),
+    fillExtrusionPattern: compile(fillExtrusionPatternFrag, fillExtrusionPatternVert),
+    hillshadePrepare: compile(hillshadePrepareFrag, hillshadePrepareVert),
+    hillshade: compile(hillshadeFrag, hillshadeVert),
+    line: compile(lineFrag, lineVert),
+    lineGradient: compile(lineGradientFrag, lineGradientVert),
+    linePattern: compile(linePatternFrag, linePatternVert),
+    lineSDF: compile(lineSDFFrag, lineSDFVert),
+    raster: compile(rasterFrag, rasterVert),
+    symbolIcon: compile(symbolIconFrag, symbolIconVert),
+    symbolSDF: compile(symbolSDFFrag, symbolSDFVert),
+    symbolTextAndIcon: compile(symbolTextAndIconFrag, symbolTextAndIconVert),
+    terrain: compile(terrainFrag, terrainVert),
+    terrainDepth: compile(terrainDepthFrag, terrainDepthVert),
+    terrainCoords: compile(terrainCoordsFrag, terrainCoordsVert),
+    sky: compile(skyFrag, skyVert)};
+
+// Expand #pragmas to #ifdefs.
+
+function compile(fragmentSource, vertexSource) {
+    const re = /#pragma mapbox: ([\w]+) ([\w]+) ([\w]+) ([\w]+)/g;
+
+    const staticAttributes = vertexSource.match(/attribute ([\w]+) ([\w]+)/g);
+    const fragmentUniforms = fragmentSource.match(/uniform ([\w]+) ([\w]+)([\s]*)([\w]*)/g);
+    const vertexUniforms = vertexSource.match(/uniform ([\w]+) ([\w]+)([\s]*)([\w]*)/g);
+    const staticUniforms = vertexUniforms ? vertexUniforms.concat(fragmentUniforms) : fragmentUniforms;
+
+    const fragmentPragmas = {};
+
+    fragmentSource = 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
+`;
+        } else /* if (operation === 'initialize') */ {
+            return `
+#ifdef HAS_UNIFORM_u_${name}
+    ${precision} ${type} ${name} = u_${name};
+#endif
+`;
+        }
+    });
+
+    vertexSource = 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 u_${name}_t;
+attribute ${precision} ${attrType} a_${name};
+varying ${precision} ${type} ${name};
+#else
+uniform ${precision} ${type} u_${name};
+#endif
+`;
+            } else /* if (operation === 'initialize') */ {
+                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
+`;
+                } else {
+                    return `
+#ifndef HAS_UNIFORM_u_${name}
+    ${name} = unpack_mix_${unpackType}(a_${name}, u_${name}_t);
+#else
+    ${precision} ${type} ${name} = u_${name};
+#endif
+`;
+                }
+            }
+        } else {
+            if (operation === 'define') {
+                return `
+#ifndef HAS_UNIFORM_u_${name}
+uniform lowp float u_${name}_t;
+attribute ${precision} ${attrType} a_${name};
+#else
+uniform ${precision} ${type} u_${name};
+#endif
+`;
+            } else /* if (operation === 'initialize') */ {
+                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
+`;
+                } else /* */ {
+                    return `
+#ifndef HAS_UNIFORM_u_${name}
+    ${precision} ${type} ${name} = unpack_mix_${unpackType}(a_${name}, u_${name}_t);
+#else
+    ${precision} ${type} ${name} = u_${name};
+#endif
+`;
+                }
+            }
+        }
+    });
+
+    return {fragmentSource, vertexSource, staticAttributes, staticUniforms};
+}

package/src/shaders/sky.fragment.glsl

@@ -0,0 +1,17 @@
+uniform vec4 u_sky_color;
+uniform vec4 u_horizon_color;
+
+uniform float u_horizon;
+uniform float u_sky_horizon_blend;
+
+void main() {
+    float y = gl_FragCoord.y;
+    if (y > u_horizon) {
+        float blend = y - u_horizon;
+        if (blend < u_sky_horizon_blend) {
+            gl_FragColor = mix(u_sky_color, u_horizon_color, pow(1.0 - blend / u_sky_horizon_blend, 2.0));
+        } else {
+            gl_FragColor = u_sky_color;
+        }
+    }
+}

package/src/shaders/sky.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_sky_color;uniform vec4 u_horizon_color;uniform float u_horizon;uniform float u_sky_horizon_blend;void main() {float y=gl_FragCoord.y;if (y > u_horizon) {float blend=y-u_horizon;if (blend < u_sky_horizon_blend) {gl_FragColor=mix(u_sky_color,u_horizon_color,pow(1.0-blend/u_sky_horizon_blend,2.0));} else {gl_FragColor=u_sky_color;}}}';

package/src/shaders/sky.vertex.glsl

@@ -0,0 +1,5 @@
+attribute vec2 a_pos;
+
+void main() {
+    gl_Position = vec4(a_pos, 1.0, 1.0);
+}

package/src/shaders/sky.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;void main() {gl_Position=vec4(a_pos,1.0,1.0);}';

package/src/shaders/symbol_icon.fragment.glsl

@@ -0,0 +1,17 @@
+uniform sampler2D u_texture;
+
+in vec2 v_tex;
+in float v_fade_opacity;
+
+#pragma mapbox: define lowp float opacity
+
+void main() {
+    #pragma mapbox: initialize lowp float opacity
+
+    lowp float alpha = opacity * v_fade_opacity;
+    fragColor = texture(u_texture, v_tex) * alpha;
+
+#ifdef OVERDRAW_INSPECTOR
+    fragColor = vec4(1.0);
+#endif
+}

package/src/shaders/symbol_icon.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 sampler2D u_texture;varying vec2 v_tex;varying float v_fade_opacity;\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nlowp float alpha=opacity*v_fade_opacity;gl_FragColor=texture2D(u_texture,v_tex)*alpha;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}';

package/src/shaders/symbol_icon.vertex.glsl

@@ -0,0 +1,117 @@
+in vec4 a_pos_offset;
+in vec4 a_data;
+in vec4 a_pixeloffset;
+in vec3 a_projected_pos;
+in float a_fade_opacity;
+
+uniform bool u_is_size_zoom_constant;
+uniform bool u_is_size_feature_constant;
+uniform highp float u_size_t; // used to interpolate between zoom stops when size is a composite function
+uniform highp float u_size; // used when size is both zoom and feature constant
+uniform highp float u_camera_to_center_distance;
+uniform highp float u_pitch;
+uniform bool u_rotate_symbol;
+uniform highp float u_aspect_ratio;
+uniform float u_fade_change;
+uniform mat4 u_matrix;
+uniform mat4 u_label_plane_matrix;
+uniform mat4 u_coord_matrix;
+uniform bool u_is_text;
+uniform bool u_pitch_with_map;
+uniform vec2 u_texsize;
+uniform bool u_is_along_line;
+uniform bool u_is_variable_anchor;
+uniform vec2 u_translation;
+uniform float u_pitched_scale;
+
+out vec2 v_tex;
+out float v_fade_opacity;
+
+vec4 projectTileWithElevation(vec2 posInTile, float elevation) {
+    return u_matrix * vec4(posInTile, elevation, 1.0);
+}
+
+#pragma mapbox: define lowp float opacity
+
+void main() {
+    #pragma mapbox: initialize lowp float opacity
+
+    vec2 a_pos = a_pos_offset.xy;
+    vec2 a_offset = a_pos_offset.zw;
+
+    vec2 a_tex = a_data.xy;
+    vec2 a_size = a_data.zw;
+
+    float a_size_min = floor(a_size[0] * 0.5);
+    vec2 a_pxoffset = a_pixeloffset.xy;
+    vec2 a_minFontScale = a_pixeloffset.zw / 256.0;
+
+    float ele = get_elevation(a_pos);
+    highp float segment_angle = -a_projected_pos[2];
+    float size;
+
+    if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {
+        size = mix(a_size_min, a_size[1], u_size_t) / 128.0;
+    } else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {
+        size = a_size_min / 128.0;
+    } else {
+        size = u_size;
+    }
+
+    vec2 translated_a_pos = a_pos + u_translation;
+    vec4 projectedPoint = projectTileWithElevation(translated_a_pos, ele);
+
+    highp float camera_to_anchor_distance = projectedPoint.w;
+    // See comments in symbol_sdf.vertex
+    highp float distance_ratio = u_pitch_with_map ?
+        camera_to_anchor_distance / u_camera_to_center_distance :
+        u_camera_to_center_distance / camera_to_anchor_distance;
+    highp float perspective_ratio = clamp(
+            0.5 + 0.5 * distance_ratio,
+            0.0, // Prevents oversized near-field symbols in pitched/overzoomed tiles
+            4.0);
+
+    size *= perspective_ratio;
+
+    float fontScale = u_is_text ? size / 24.0 : size;
+
+    highp float symbol_rotation = 0.0;
+    if (u_rotate_symbol) {
+        // See comments in symbol_sdf.vertex
+        vec4 offsetProjectedPoint = projectTileWithElevation(translated_a_pos + vec2(1, 0), ele);
+
+        vec2 a = projectedPoint.xy / projectedPoint.w;
+        vec2 b = offsetProjectedPoint.xy / offsetProjectedPoint.w;
+
+        symbol_rotation = atan((b.y - a.y) / u_aspect_ratio, b.x - a.x);
+    }
+
+    highp float angle_sin = sin(segment_angle + symbol_rotation);
+    highp float angle_cos = cos(segment_angle + symbol_rotation);
+    mat2 rotation_matrix = mat2(angle_cos, -1.0 * angle_sin, angle_sin, angle_cos);
+
+    vec4 projected_pos;
+    if (u_is_along_line || u_is_variable_anchor) {
+        projected_pos = vec4(a_projected_pos.xy, ele, 1.0);
+    } else if (u_pitch_with_map) {
+        projected_pos = u_label_plane_matrix * vec4(a_projected_pos.xy + u_translation, ele, 1.0);
+    } else {
+        projected_pos = u_label_plane_matrix * projectTileWithElevation(a_projected_pos.xy + u_translation, ele);
+    }
+
+    float z = float(u_pitch_with_map) * projected_pos.z / projected_pos.w;
+
+    float projectionScaling = 1.0;
+
+    vec4 finalPos = u_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 32.0 * max(a_minFontScale, fontScale) + a_pxoffset / 16.0) * projectionScaling, z, 1.0);
+    if(u_pitch_with_map) {
+        finalPos = projectTileWithElevation(finalPos.xy, finalPos.z);
+    }
+    gl_Position = finalPos;
+
+    v_tex = a_tex / u_texsize;
+    vec2 fade_opacity = unpack_opacity(a_fade_opacity);
+    float fade_change = fade_opacity[1] > 0.5 ? u_fade_change : -u_fade_change;
+    float visibility = calculate_visibility(projectedPoint);
+    v_fade_opacity = max(0.0, min(visibility, fade_opacity[0] + fade_change));
+}

package/src/shaders/symbol_icon.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 vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform highp float u_camera_to_center_distance;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform float u_fade_change;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;varying vec2 v_tex;varying float v_fade_opacity;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;vec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}gl_Position=finalPos;v_tex=a_tex/u_texsize;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float visibility=calculate_visibility(projectedPoint);v_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));}';