summaryrefslogtreecommitdiff
path: root/src/mbgl
diff options
context:
space:
mode:
authorJohn Firebaugh <john.firebaugh@gmail.com>2018-07-24 15:40:33 -0700
committerJohn Firebaugh <john.firebaugh@gmail.com>2018-07-25 11:39:05 -0700
commit888a516f1fec172081c06f4d2a98c08ae13a4d93 (patch)
tree9b25c54d9aa8866f500e8393a1a238f901a5835e /src/mbgl
parent524a645f0b3b2c6e2891f3e07eff7305b575b2f9 (diff)
downloadqtlocation-mapboxgl-888a516f1fec172081c06f4d2a98c08ae13a4d93.tar.gz
[core] Compress shader source code
Diffstat (limited to 'src/mbgl')
-rw-r--r--src/mbgl/shaders/background.cpp68
-rw-r--r--src/mbgl/shaders/background_pattern.cpp135
-rw-r--r--src/mbgl/shaders/circle.cpp497
-rw-r--r--src/mbgl/shaders/clipping_mask.cpp51
-rw-r--r--src/mbgl/shaders/collision_box.cpp141
-rw-r--r--src/mbgl/shaders/collision_circle.cpp205
-rw-r--r--src/mbgl/shaders/debug.cpp55
-rw-r--r--src/mbgl/shaders/extrusion_texture.cpp83
-rw-r--r--src/mbgl/shaders/fill.cpp157
-rw-r--r--src/mbgl/shaders/fill_extrusion.cpp321
-rw-r--r--src/mbgl/shaders/fill_extrusion_pattern.cpp305
-rw-r--r--src/mbgl/shaders/fill_outline.cpp181
-rw-r--r--src/mbgl/shaders/fill_outline_pattern.cpp213
-rw-r--r--src/mbgl/shaders/fill_pattern.cpp185
-rw-r--r--src/mbgl/shaders/heatmap.cpp313
-rw-r--r--src/mbgl/shaders/heatmap_texture.cpp91
-rw-r--r--src/mbgl/shaders/hillshade.cpp251
-rw-r--r--src/mbgl/shaders/hillshade_prepare.cpp249
-rw-r--r--src/mbgl/shaders/line.cpp494
-rw-r--r--src/mbgl/shaders/line_pattern.cpp544
-rw-r--r--src/mbgl/shaders/line_sdf.cpp604
-rw-r--r--src/mbgl/shaders/preludes.cpp244
-rw-r--r--src/mbgl/shaders/raster.cpp211
-rw-r--r--src/mbgl/shaders/symbol_icon.cpp321
-rw-r--r--src/mbgl/shaders/symbol_sdf.cpp610
25 files changed, 3675 insertions, 2854 deletions
diff --git a/src/mbgl/shaders/background.cpp b/src/mbgl/shaders/background.cpp
index 3eafa47b49..e9eb315939 100644
--- a/src/mbgl/shaders/background.cpp
+++ b/src/mbgl/shaders/background.cpp
@@ -1,34 +1,56 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/background.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* background::name = "background";
-const char* background::vertexSource = R"MBGL_SHADER(
-attribute vec2 a_pos;
-
-uniform mat4 u_matrix;
-
-void main() {
- gl_Position = u_matrix * vec4(a_pos, 0, 1);
-}
-
-)MBGL_SHADER";
-const char* background::fragmentSource = R"MBGL_SHADER(
-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
-}
-
-)MBGL_SHADER";
+const char* background::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x4b, 0x2c, 0x29, 0x29, 0xca, 0x4c,
+ 0x2a, 0x2d, 0x49, 0x55, 0x28, 0x4b, 0x4d, 0x36,
+ 0x52, 0x48, 0x8c, 0x2f, 0xc8, 0x2f, 0xb6, 0xe6,
+ 0xe2, 0x2a, 0xcd, 0xcb, 0x4c, 0xcb, 0x2f, 0xca,
+ 0x55, 0xc8, 0x4d, 0x2c, 0x31, 0x51, 0x28, 0x8d,
+ 0x07, 0x52, 0x45, 0x99, 0x15, 0x40, 0xf1, 0xb2,
+ 0xfc, 0xcc, 0x14, 0xa0, 0x60, 0x66, 0x9e, 0x86,
+ 0xa6, 0x42, 0x35, 0x97, 0x02, 0x10, 0xa4, 0xe7,
+ 0xc4, 0x07, 0xe4, 0x17, 0x67, 0x96, 0x64, 0xe6,
+ 0xe7, 0x29, 0xd8, 0xc2, 0x95, 0x2a, 0x68, 0x81,
+ 0xcc, 0x33, 0xd1, 0x00, 0x9b, 0xa7, 0xa3, 0x60,
+ 0xa0, 0xa3, 0x60, 0xa8, 0x69, 0xcd, 0x55, 0xcb,
+ 0x05, 0x00, 0x45, 0x7b, 0x23, 0xb2
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* background::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x2b, 0xcd, 0xcb, 0x4c, 0xcb, 0x2f,
+ 0xca, 0x55, 0x28, 0x4b, 0x4d, 0x36, 0x51, 0x28,
+ 0x8d, 0x4f, 0xce, 0xcf, 0xc9, 0x2f, 0xb2, 0xe6,
+ 0x2a, 0x85, 0x8a, 0xa6, 0xe5, 0xe4, 0x27, 0x96,
+ 0x00, 0x85, 0xf3, 0x0b, 0x12, 0x93, 0x33, 0x4b,
+ 0x2a, 0xad, 0xb9, 0xb8, 0xca, 0xf2, 0x33, 0x53,
+ 0x14, 0x72, 0x13, 0x33, 0xf3, 0x34, 0x34, 0x15,
+ 0xaa, 0xb9, 0x14, 0x80, 0x20, 0x3d, 0x27, 0xde,
+ 0xad, 0x28, 0x31, 0xdd, 0x19, 0xa4, 0x53, 0xc1,
+ 0x16, 0x66, 0x86, 0x82, 0x16, 0x8a, 0x36, 0xe5,
+ 0xcc, 0xb4, 0x94, 0xd4, 0x34, 0x05, 0xff, 0x30,
+ 0xd7, 0x20, 0x97, 0x20, 0xc7, 0xf0, 0x78, 0x4f,
+ 0xbf, 0xe0, 0x00, 0x57, 0xe7, 0x10, 0xff, 0x20,
+ 0x6c, 0x46, 0x80, 0xdc, 0xa2, 0x61, 0xa8, 0x67,
+ 0xa0, 0x69, 0xcd, 0xa5, 0x9c, 0x9a, 0x97, 0x92,
+ 0x99, 0xc6, 0x55, 0xcb, 0x05, 0x00, 0xbb, 0x66,
+ 0x35, 0xbb
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/background_pattern.cpp b/src/mbgl/shaders/background_pattern.cpp
index 6fd0a53d19..83f4307bea 100644
--- a/src/mbgl/shaders/background_pattern.cpp
+++ b/src/mbgl/shaders/background_pattern.cpp
@@ -1,65 +1,92 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/background_pattern.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* background_pattern::name = "background_pattern";
-const char* background_pattern::vertexSource = R"MBGL_SHADER(
-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);
-}
-
-)MBGL_SHADER";
-const char* background_pattern::fragmentSource = R"MBGL_SHADER(
-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
-}
-
-)MBGL_SHADER";
+const char* background_pattern::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0xad, 0x91, 0x4d, 0x6e, 0xc3, 0x20,
+ 0x10, 0x85, 0xf7, 0x9c, 0x82, 0xa5, 0x5d, 0xb1,
+ 0x48, 0xa2, 0xec, 0xa2, 0xde, 0x21, 0x37, 0x40,
+ 0xe0, 0x60, 0x6b, 0x24, 0xc2, 0x58, 0x30, 0x38,
+ 0x7f, 0xca, 0xdd, 0x33, 0xd4, 0x51, 0xd2, 0xd4,
+ 0x6e, 0xba, 0x29, 0x1b, 0xa4, 0x6f, 0xde, 0xe8,
+ 0x3d, 0x1e, 0x39, 0x40, 0x8b, 0x71, 0x2f, 0xf7,
+ 0x86, 0xd6, 0x32, 0x6b, 0xbe, 0x22, 0x1c, 0x37,
+ 0x22, 0xdf, 0xf1, 0xe0, 0x9a, 0x15, 0xe3, 0xde,
+ 0x10, 0xb9, 0x18, 0x74, 0x82, 0xb3, 0xd3, 0xe6,
+ 0xfd, 0xd8, 0x4e, 0xc7, 0x70, 0x74, 0x5e, 0x37,
+ 0x88, 0x71, 0xa7, 0x73, 0xdf, 0xbb, 0xf8, 0x56,
+ 0xe1, 0xf1, 0xf0, 0x5d, 0xd1, 0x7a, 0x34, 0xc4,
+ 0x92, 0xd4, 0x18, 0xff, 0xe2, 0xfd, 0x3a, 0xb0,
+ 0xd3, 0x01, 0x01, 0x73, 0x86, 0x94, 0x34, 0xe1,
+ 0x68, 0x91, 0x36, 0x42, 0x70, 0xd6, 0x08, 0x36,
+ 0x93, 0x1b, 0xcd, 0x8d, 0xee, 0xb1, 0xe0, 0xc1,
+ 0xc4, 0x13, 0x84, 0x6e, 0x84, 0x43, 0x81, 0xc5,
+ 0x6c, 0x86, 0xda, 0x22, 0x46, 0xd8, 0x71, 0x65,
+ 0x10, 0xaa, 0x5a, 0x5e, 0x84, 0xe4, 0xd3, 0x79,
+ 0xbd, 0xc5, 0x04, 0x04, 0x18, 0xe4, 0xe7, 0xa3,
+ 0x48, 0xf9, 0x51, 0x36, 0xd7, 0xd5, 0x97, 0x89,
+ 0x92, 0x0b, 0x25, 0x97, 0x35, 0xaf, 0x97, 0x85,
+ 0xbb, 0x05, 0x8b, 0x3b, 0x47, 0x8f, 0x06, 0x99,
+ 0x55, 0x33, 0x85, 0xa9, 0xb9, 0x8e, 0xd4, 0xb3,
+ 0x15, 0xf6, 0xf9, 0xf9, 0x49, 0xea, 0x97, 0x06,
+ 0xd4, 0xf8, 0x62, 0x8e, 0xf1, 0x4c, 0x61, 0xff,
+ 0x25, 0x85, 0x9d, 0xa6, 0xb0, 0x7f, 0xa7, 0xb8,
+ 0x8a, 0x1b, 0x2c, 0x40, 0xe9, 0xd0
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* background_pattern::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x7d, 0x91, 0x41, 0x4f, 0x84, 0x30,
+ 0x10, 0x85, 0xef, 0xfd, 0x15, 0x93, 0xec, 0x05,
+ 0x0c, 0x51, 0xb7, 0xf1, 0x46, 0x3c, 0x98, 0x65,
+ 0x4d, 0xbc, 0xb8, 0x06, 0x8d, 0x1e, 0x9b, 0x16,
+ 0x0a, 0x69, 0x42, 0x29, 0x29, 0x65, 0xc3, 0x6a,
+ 0xfc, 0xef, 0xb6, 0x0b, 0x4a, 0x90, 0x2e, 0x3d,
+ 0xce, 0x7b, 0x7d, 0xf3, 0xcd, 0x4c, 0x57, 0x8b,
+ 0x42, 0x69, 0x09, 0x47, 0x9e, 0x61, 0xe8, 0x48,
+ 0x43, 0x8d, 0xe1, 0xba, 0x26, 0xa6, 0x22, 0x34,
+ 0x46, 0x9d, 0x5f, 0x64, 0x7a, 0x45, 0xb4, 0x3f,
+ 0xd9, 0xda, 0xcf, 0xa5, 0x68, 0x78, 0xdf, 0x8a,
+ 0x4f, 0x3e, 0xd5, 0x8b, 0x4a, 0x51, 0x63, 0x05,
+ 0x29, 0xfa, 0x65, 0x51, 0x35, 0x34, 0x13, 0xe6,
+ 0x14, 0xa3, 0x3f, 0xa5, 0xa5, 0xb2, 0xa9, 0xb8,
+ 0xc6, 0x89, 0x55, 0x85, 0xa4, 0xa5, 0x4d, 0x42,
+ 0x47, 0xaa, 0x4f, 0xa2, 0x2e, 0x87, 0x16, 0x47,
+ 0xd2, 0xa8, 0xd6, 0x21, 0x7b, 0xaa, 0xcc, 0x99,
+ 0x95, 0xc8, 0x41, 0x52, 0x51, 0x07, 0x21, 0x7c,
+ 0x21, 0xb0, 0xef, 0x6c, 0x38, 0x67, 0x65, 0x4a,
+ 0xe9, 0x1c, 0xee, 0x41, 0xaa, 0x3c, 0x18, 0x73,
+ 0x22, 0xd8, 0x5e, 0xdf, 0x86, 0xf1, 0x64, 0xb4,
+ 0x55, 0xe7, 0x10, 0x7d, 0x30, 0x5f, 0x20, 0xdc,
+ 0x4c, 0xd3, 0x45, 0xff, 0xf6, 0x37, 0xd7, 0xa6,
+ 0x56, 0x53, 0xee, 0x1d, 0x64, 0xaa, 0x52, 0x7a,
+ 0x6b, 0xa3, 0xad, 0xcf, 0x74, 0x9a, 0xe3, 0x24,
+ 0x18, 0x27, 0x8c, 0x5c, 0x4f, 0x6b, 0xf5, 0xc1,
+ 0x12, 0x36, 0xc3, 0x65, 0x3e, 0x5c, 0xec, 0xe3,
+ 0x65, 0x2b, 0xbc, 0xec, 0x12, 0x2f, 0x61, 0x0b,
+ 0x62, 0x7c, 0x91, 0x18, 0xff, 0x22, 0x97, 0x15,
+ 0x79, 0xd4, 0xb4, 0xdc, 0x39, 0xfb, 0x88, 0x32,
+ 0x0c, 0x1b, 0x8d, 0x11, 0xd1, 0x70, 0xfe, 0x10,
+ 0xae, 0x66, 0x27, 0xdf, 0x88, 0x22, 0xe7, 0x05,
+ 0x1c, 0xde, 0xf7, 0x69, 0x92, 0x3e, 0x7c, 0x90,
+ 0xa7, 0xe7, 0xd7, 0x97, 0xfd, 0xee, 0xed, 0x90,
+ 0xfa, 0x52, 0x1d, 0x51, 0x30, 0xcc, 0xbe, 0xe1,
+ 0x75, 0x2e, 0x0a, 0xf4, 0x8d, 0x7e, 0x00, 0x79,
+ 0xe0, 0xfb, 0xaf
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/circle.cpp b/src/mbgl/shaders/circle.cpp
index c14335914b..ded6979634 100644
--- a/src/mbgl/shaders/circle.cpp
+++ b/src/mbgl/shaders/circle.cpp
@@ -1,287 +1,232 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/circle.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* circle::name = "circle";
-const char* circle::vertexSource = R"MBGL_SHADER(
-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;
-
-
-#ifndef HAS_UNIFORM_u_color
-uniform lowp float a_color_t;
-attribute highp vec4 a_color;
-varying highp vec4 color;
-#else
-uniform highp vec4 u_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_radius
-uniform lowp float a_radius_t;
-attribute mediump vec2 a_radius;
-varying mediump float radius;
-#else
-uniform mediump float u_radius;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_blur
-uniform lowp float a_blur_t;
-attribute lowp vec2 a_blur;
-varying lowp float blur;
-#else
-uniform lowp float u_blur;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-uniform lowp float a_opacity_t;
-attribute lowp vec2 a_opacity;
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_stroke_color
-uniform lowp float a_stroke_color_t;
-attribute highp vec4 a_stroke_color;
-varying highp vec4 stroke_color;
-#else
-uniform highp vec4 u_stroke_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_stroke_width
-uniform lowp float a_stroke_width_t;
-attribute mediump vec2 a_stroke_width;
-varying mediump float stroke_width;
-#else
-uniform mediump float u_stroke_width;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_stroke_opacity
-uniform lowp float a_stroke_opacity_t;
-attribute lowp vec2 a_stroke_opacity;
-varying lowp float stroke_opacity;
-#else
-uniform lowp float u_stroke_opacity;
-#endif
-
-
-varying vec3 v_data;
-
-void main(void) {
-
-#ifndef HAS_UNIFORM_u_color
- color = unpack_mix_vec4(a_color, a_color_t);
-#else
- highp vec4 color = u_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_radius
- radius = unpack_mix_vec2(a_radius, a_radius_t);
-#else
- mediump float radius = u_radius;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_blur
- blur = unpack_mix_vec2(a_blur, a_blur_t);
-#else
- lowp float blur = u_blur;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
- opacity = unpack_mix_vec2(a_opacity, a_opacity_t);
-#else
- lowp float opacity = u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_stroke_color
- stroke_color = unpack_mix_vec4(a_stroke_color, a_stroke_color_t);
-#else
- highp vec4 stroke_color = u_stroke_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_stroke_width
- stroke_width = unpack_mix_vec2(a_stroke_width, a_stroke_width_t);
-#else
- mediump float stroke_width = u_stroke_width;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_stroke_opacity
- stroke_opacity = unpack_mix_vec2(a_stroke_opacity, a_stroke_opacity_t);
-#else
- lowp float stroke_opacity = u_stroke_opacity;
-#endif
-
-
- // 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);
-}
-
-)MBGL_SHADER";
-const char* circle::fragmentSource = R"MBGL_SHADER(
-
-#ifndef HAS_UNIFORM_u_color
-varying highp vec4 color;
-#else
-uniform highp vec4 u_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_radius
-varying mediump float radius;
-#else
-uniform mediump float u_radius;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_blur
-varying lowp float blur;
-#else
-uniform lowp float u_blur;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_stroke_color
-varying highp vec4 stroke_color;
-#else
-uniform highp vec4 u_stroke_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_stroke_width
-varying mediump float stroke_width;
-#else
-uniform mediump float u_stroke_width;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_stroke_opacity
-varying lowp float stroke_opacity;
-#else
-uniform lowp float u_stroke_opacity;
-#endif
-
-
-varying vec3 v_data;
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_color
- highp vec4 color = u_color;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_radius
- mediump float radius = u_radius;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_blur
- lowp float blur = u_blur;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_opacity
- lowp float opacity = u_opacity;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_stroke_color
- highp vec4 stroke_color = u_stroke_color;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_stroke_width
- mediump float stroke_width = u_stroke_width;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_stroke_opacity
- lowp float stroke_opacity = u_stroke_opacity;
-#endif
-
-
- 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
-}
-
-)MBGL_SHADER";
+const char* circle::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0xb5, 0x57, 0xcb, 0x6e, 0xdc, 0x36,
+ 0x14, 0xdd, 0xcf, 0x57, 0x10, 0xc8, 0xa2, 0xe3,
+ 0x44, 0x1e, 0x3f, 0x92, 0x6c, 0x3a, 0xf0, 0x22,
+ 0x68, 0x5d, 0xd4, 0x40, 0xdb, 0x18, 0x69, 0x52,
+ 0x74, 0x27, 0x70, 0x24, 0xca, 0x62, 0x47, 0x12,
+ 0x05, 0x8a, 0x9a, 0x47, 0x0b, 0xff, 0x7b, 0xef,
+ 0x25, 0x29, 0x89, 0xd4, 0x83, 0x4e, 0x8b, 0xd6,
+ 0x1b, 0x6b, 0x78, 0x0f, 0xcf, 0x3d, 0x24, 0x8f,
+ 0xce, 0x70, 0xda, 0x8a, 0x67, 0x42, 0x96, 0xa4,
+ 0xa4, 0xea, 0x1d, 0x69, 0x63, 0xf8, 0x27, 0xf9,
+ 0x69, 0xbb, 0x6a, 0xed, 0xf0, 0x4e, 0x88, 0x02,
+ 0x86, 0x9b, 0x84, 0x16, 0x2c, 0x3e, 0x72, 0x95,
+ 0x03, 0xa2, 0x9e, 0x94, 0x6b, 0xae, 0x92, 0x7c,
+ 0xa6, 0x7c, 0x60, 0xc9, 0x2d, 0x94, 0xd9, 0x49,
+ 0xc9, 0x36, 0x65, 0x86, 0x65, 0xa8, 0xe6, 0xfc,
+ 0x29, 0xaf, 0x49, 0x56, 0x08, 0xaa, 0x00, 0x94,
+ 0xd0, 0x92, 0x49, 0x1a, 0x2b, 0x11, 0x27, 0xac,
+ 0x52, 0x4c, 0xc6, 0x29, 0x6f, 0x14, 0xad, 0x12,
+ 0x98, 0xb0, 0xa2, 0x0a, 0x54, 0xed, 0x5a, 0xc5,
+ 0x0c, 0x23, 0x8d, 0x6b, 0xd1, 0xc0, 0xf0, 0xea,
+ 0x15, 0xcf, 0xaa, 0x94, 0x65, 0xe4, 0xc7, 0x0f,
+ 0xbf, 0xc6, 0x5f, 0x7e, 0x79, 0xf8, 0xe1, 0xe3,
+ 0xa7, 0x9f, 0x63, 0x60, 0x12, 0x85, 0x90, 0x7d,
+ 0x97, 0x42, 0x1c, 0xbb, 0x26, 0xd4, 0x94, 0x62,
+ 0xb5, 0x75, 0x18, 0x8d, 0x0a, 0xe0, 0x7d, 0xd7,
+ 0xd5, 0xb7, 0xab, 0x03, 0x95, 0x67, 0x5e, 0x3d,
+ 0xb9, 0x35, 0x5b, 0x79, 0xc5, 0x8a, 0x86, 0x8d,
+ 0x56, 0xa0, 0xeb, 0x6d, 0xdc, 0x23, 0xaa, 0x94,
+ 0x67, 0x8b, 0xe2, 0x24, 0x4d, 0x79, 0xdb, 0xcc,
+ 0xab, 0x33, 0x35, 0x5f, 0x5e, 0xc9, 0x60, 0xac,
+ 0xac, 0xbb, 0x85, 0x1b, 0xc8, 0xa0, 0xb0, 0x2b,
+ 0x1b, 0x8a, 0xae, 0xea, 0xab, 0xf4, 0x31, 0x6d,
+ 0x3c, 0xa0, 0x82, 0x4a, 0x77, 0x45, 0xbb, 0xb0,
+ 0x8b, 0x58, 0xf1, 0x55, 0xea, 0xb2, 0x95, 0x88,
+ 0xd5, 0x41, 0xa0, 0x33, 0xd1, 0x14, 0x7c, 0x6d,
+ 0x4e, 0xb9, 0x8d, 0x3b, 0x40, 0x50, 0x96, 0xa8,
+ 0x69, 0xc2, 0xd5, 0x79, 0x5e, 0x99, 0x2d, 0x2e,
+ 0x8b, 0xb3, 0x80, 0x59, 0x7d, 0x7d, 0x2d, 0x20,
+ 0xd1, 0xc1, 0x04, 0x55, 0x36, 0x4a, 0x8a, 0x3d,
+ 0x0b, 0x59, 0xd1, 0x45, 0x04, 0x1c, 0xe9, 0xc2,
+ 0x66, 0x8d, 0xe9, 0x03, 0x02, 0xfe, 0x1c, 0x03,
+ 0xbf, 0x46, 0xff, 0x91, 0xa7, 0x2a, 0x0f, 0xea,
+ 0xd7, 0x88, 0xa0, 0x65, 0x5d, 0xe0, 0x92, 0x71,
+ 0x7d, 0x4c, 0xd8, 0xbe, 0x63, 0xec, 0xd7, 0xac,
+ 0x23, 0x68, 0x1a, 0x1f, 0xb3, 0xec, 0x1d, 0x1f,
+ 0x37, 0x6b, 0xa1, 0x31, 0x24, 0xe0, 0xa4, 0x29,
+ 0xd4, 0x2e, 0xa4, 0xa3, 0x85, 0xae, 0x6f, 0xc9,
+ 0x21, 0x4e, 0xa9, 0xa2, 0x90, 0x75, 0x07, 0xc1,
+ 0x53, 0x08, 0x69, 0x5e, 0xad, 0xf1, 0xe9, 0x82,
+ 0xfc, 0xb5, 0x22, 0xf0, 0x17, 0x4c, 0x40, 0x04,
+ 0xe8, 0x27, 0x72, 0x47, 0xda, 0x0a, 0xfa, 0xec,
+ 0xe3, 0x92, 0x9f, 0x62, 0xb4, 0xc3, 0xda, 0x46,
+ 0x5d, 0x34, 0x64, 0xe2, 0x45, 0xa7, 0x16, 0xa7,
+ 0x8d, 0x83, 0x0f, 0x19, 0xc6, 0xce, 0x09, 0xf4,
+ 0xb7, 0x21, 0x87, 0x08, 0xf3, 0x38, 0x51, 0x70,
+ 0xbb, 0xee, 0xb2, 0x2c, 0x72, 0x82, 0xcf, 0xd3,
+ 0x30, 0x17, 0x6d, 0x5a, 0xc7, 0x38, 0xbf, 0x02,
+ 0x42, 0x74, 0x86, 0x61, 0x1d, 0x1f, 0x66, 0x45,
+ 0x60, 0x21, 0xea, 0x33, 0xcd, 0x13, 0x30, 0x8a,
+ 0x2e, 0xdd, 0xdb, 0x8f, 0xa8, 0x40, 0xe7, 0xce,
+ 0x71, 0x08, 0xb1, 0xcf, 0xb3, 0xfd, 0x6d, 0x2d,
+ 0x72, 0xc3, 0x6b, 0x49, 0x85, 0xc3, 0x33, 0xf5,
+ 0x4d, 0x40, 0x8b, 0x17, 0x46, 0x88, 0x73, 0x07,
+ 0x66, 0xcd, 0xe1, 0x02, 0xa2, 0x49, 0x58, 0x2d,
+ 0x59, 0x65, 0x4c, 0xbb, 0x10, 0x39, 0x2f, 0x2b,
+ 0x35, 0xb1, 0xe3, 0x28, 0xd5, 0x03, 0xb3, 0xfb,
+ 0xe7, 0x02, 0xa2, 0x49, 0x2c, 0x05, 0x0c, 0x35,
+ 0x66, 0x5e, 0xc8, 0x95, 0x97, 0xc5, 0xba, 0x27,
+ 0xed, 0x0f, 0x85, 0x04, 0x3b, 0xe7, 0x3e, 0xce,
+ 0x9f, 0xa5, 0xe3, 0x9f, 0x92, 0x2f, 0x87, 0x08,
+ 0x4e, 0xbd, 0xba, 0x82, 0xf6, 0xac, 0x4a, 0x44,
+ 0xca, 0x88, 0xca, 0x19, 0xd1, 0xd7, 0xb0, 0x86,
+ 0x8b, 0x0a, 0x4f, 0x4b, 0xc1, 0x11, 0xa9, 0x1c,
+ 0x58, 0x8f, 0x8c, 0x34, 0x55, 0x9b, 0xec, 0x09,
+ 0xaf, 0x94, 0xd0, 0x38, 0x7d, 0xbd, 0xb2, 0x18,
+ 0x4d, 0xa4, 0xf3, 0xcf, 0x5e, 0xe2, 0xa0, 0xad,
+ 0x5e, 0x48, 0x29, 0xd2, 0xb5, 0x06, 0x46, 0xe4,
+ 0x76, 0x73, 0x7d, 0x41, 0x5e, 0xe3, 0x3f, 0x72,
+ 0x49, 0x6e, 0xe0, 0xc3, 0xb6, 0xef, 0x5f, 0xb6,
+ 0x85, 0xe2, 0x75, 0x71, 0xb6, 0x9c, 0xbb, 0x33,
+ 0xb9, 0xde, 0xbc, 0x8f, 0x48, 0xc3, 0xe1, 0x5e,
+ 0x87, 0x9d, 0x73, 0x9a, 0x12, 0xae, 0x70, 0x32,
+ 0xb4, 0x27, 0x42, 0xa6, 0x0c, 0x54, 0x09, 0x10,
+ 0xc4, 0xe8, 0xbe, 0xe3, 0x80, 0xc2, 0xa0, 0x1c,
+ 0xd3, 0x70, 0xd0, 0x94, 0x70, 0x99, 0xc0, 0xbd,
+ 0xd4, 0x5c, 0x18, 0x41, 0x19, 0xec, 0x93, 0x90,
+ 0x46, 0x16, 0x70, 0x42, 0x2b, 0x90, 0x82, 0x60,
+ 0x9e, 0x91, 0xf5, 0xf8, 0x96, 0xda, 0x45, 0xe8,
+ 0x40, 0x26, 0x64, 0x05, 0xd7, 0x4e, 0x98, 0xcb,
+ 0x15, 0xb6, 0xba, 0xf3, 0xe9, 0xb7, 0x3d, 0xda,
+ 0xb0, 0xf9, 0x57, 0x62, 0x97, 0xcd, 0xe4, 0xae,
+ 0x4f, 0xf6, 0xe6, 0xae, 0xdf, 0xc0, 0xd7, 0x64,
+ 0x6d, 0xc3, 0xec, 0x8d, 0x67, 0x42, 0xdc, 0xc3,
+ 0xc9, 0x5d, 0xb9, 0xe3, 0x7b, 0x26, 0xe8, 0x88,
+ 0x51, 0x13, 0xd8, 0x9c, 0x47, 0x5c, 0x13, 0x7e,
+ 0x5b, 0xe0, 0xc1, 0x19, 0xbd, 0x04, 0x35, 0xe9,
+ 0xcf, 0xa0, 0x8b, 0xb0, 0x2c, 0x83, 0x83, 0xe4,
+ 0x07, 0x06, 0x87, 0xa0, 0x39, 0x1b, 0xdc, 0x70,
+ 0x17, 0x32, 0xa6, 0xfc, 0x2c, 0x40, 0x7d, 0x8b,
+ 0x4b, 0xa6, 0x89, 0x32, 0xc6, 0xd1, 0x1c, 0x04,
+ 0xbe, 0xc3, 0x88, 0xde, 0xc3, 0x4b, 0x4d, 0xf4,
+ 0x2d, 0x39, 0x70, 0x76, 0xac, 0x85, 0x54, 0x11,
+ 0x1e, 0xa5, 0x64, 0x7a, 0x14, 0x27, 0x8c, 0x19,
+ 0x8f, 0xb9, 0x28, 0x7a, 0x75, 0x3b, 0xda, 0xb0,
+ 0x94, 0xc0, 0x96, 0x20, 0xb3, 0xa6, 0xd3, 0xba,
+ 0x70, 0x0d, 0xb6, 0x0f, 0x98, 0x92, 0xab, 0x86,
+ 0xe0, 0xb6, 0x4b, 0x5a, 0x90, 0x5a, 0x80, 0x33,
+ 0x3d, 0x4a, 0x1d, 0x36, 0xb5, 0x14, 0x7f, 0x00,
+ 0x9a, 0xa5, 0xc3, 0xf1, 0x77, 0x3f, 0x5f, 0x60,
+ 0x23, 0x75, 0x8e, 0x79, 0xe7, 0x17, 0x91, 0xeb,
+ 0x88, 0xdc, 0x5c, 0x6c, 0xff, 0x87, 0x63, 0x42,
+ 0xec, 0x58, 0xce, 0xe6, 0x48, 0xae, 0x42, 0xbf,
+ 0x6a, 0x1c, 0x21, 0xcf, 0xab, 0xfe, 0xf1, 0xa9,
+ 0x88, 0x1f, 0x07, 0xff, 0x4d, 0xd6, 0xe3, 0xab,
+ 0xf5, 0x56, 0x34, 0x31, 0xc8, 0x0b, 0x54, 0xb3,
+ 0x5b, 0xf3, 0x8f, 0x2c, 0xee, 0x34, 0xd8, 0x9c,
+ 0xce, 0xff, 0x7e, 0xeb, 0x82, 0x3f, 0xfd, 0x82,
+ 0xfe, 0xff, 0xaf, 0x14, 0xb8, 0x3c, 0x47, 0xf7,
+ 0x5c, 0x9c, 0xd3, 0xc1, 0x17, 0x23, 0xe7, 0xf0,
+ 0xf2, 0x34, 0x84, 0x92, 0x92, 0x57, 0xbc, 0x6c,
+ 0x4b, 0x73, 0x2d, 0xe8, 0xc4, 0x9a, 0x38, 0x6d,
+ 0x98, 0x3c, 0xc0, 0x3b, 0x46, 0x11, 0x96, 0xd1,
+ 0xf6, 0x74, 0x49, 0x2b, 0xc5, 0xc1, 0xde, 0xb4,
+ 0x41, 0x87, 0x67, 0x36, 0x51, 0x81, 0x6d, 0x78,
+ 0x61, 0x37, 0x36, 0x0f, 0x35, 0x9b, 0xe6, 0x97,
+ 0x14, 0xb4, 0x10, 0x91, 0x39, 0xa0, 0x6f, 0x1a,
+ 0x40, 0xfd, 0x09, 0xe1, 0x5c, 0xa5, 0x7a, 0x14,
+ 0xde, 0x09, 0xd8, 0x2b, 0x80, 0xf7, 0x7c, 0x82,
+ 0xec, 0x19, 0xab, 0x75, 0x51, 0x33, 0xe1, 0xa5,
+ 0x49, 0xb4, 0x4f, 0x39, 0xbc, 0xf8, 0x37, 0xf5,
+ 0x29, 0xd2, 0x05, 0x75, 0x14, 0x84, 0x4a, 0x9c,
+ 0x7d, 0x60, 0xb2, 0xc1, 0x4c, 0x90, 0xac, 0xa0,
+ 0xe0, 0xda, 0xcd, 0xf8, 0xcb, 0xa6, 0x97, 0x6d,
+ 0xaf, 0x3e, 0x90, 0xeb, 0x60, 0xe8, 0xef, 0xef,
+ 0x7f, 0x7b, 0xf8, 0xee, 0x3e, 0x7e, 0x7c, 0xf8,
+ 0xfd, 0xfe, 0xa7, 0xf8, 0xd3, 0x87, 0xcf, 0x0f,
+ 0x1f, 0x61, 0x70, 0x61, 0xab, 0xad, 0x9d, 0xcc,
+ 0x0d, 0xd6, 0x7c, 0x6d, 0xbc, 0x5d, 0xdb, 0xad,
+ 0xdf, 0x80, 0x9e, 0xee, 0x11, 0xbf, 0x03, 0xdd,
+ 0x66, 0x30, 0xf1, 0x79, 0xf5, 0x37, 0xfa, 0x66,
+ 0x94, 0xc5
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* circle::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x8d, 0x53, 0xcb, 0x6e, 0xdb, 0x30,
+ 0x10, 0xbc, 0xf3, 0x2b, 0x16, 0xc8, 0x45, 0x76,
+ 0x15, 0xd7, 0x69, 0x7b, 0xaa, 0x5b, 0x14, 0x41,
+ 0x9a, 0xa0, 0x39, 0x34, 0x2e, 0x9c, 0x3e, 0x8e,
+ 0x04, 0x6b, 0x51, 0x32, 0x51, 0x49, 0x34, 0x24,
+ 0xca, 0x71, 0x1a, 0xf4, 0xdf, 0xcb, 0x97, 0x1c,
+ 0x92, 0x7a, 0x45, 0x17, 0x49, 0x9c, 0xdd, 0x99,
+ 0xe5, 0xee, 0x2c, 0x3a, 0x63, 0x69, 0x99, 0xd0,
+ 0x14, 0xbe, 0x5c, 0xde, 0xe3, 0x1f, 0x77, 0xb7,
+ 0x37, 0xeb, 0xcd, 0x57, 0xdc, 0xe0, 0x2d, 0xcf,
+ 0x79, 0x85, 0x0e, 0xa4, 0x7a, 0x64, 0x65, 0x06,
+ 0x3b, 0x96, 0xed, 0xf6, 0x70, 0xa0, 0xdb, 0x77,
+ 0xa0, 0x81, 0x15, 0x3a, 0xa3, 0x79, 0x4d, 0x51,
+ 0x53, 0xb2, 0x94, 0x57, 0x85, 0x8b, 0xdb, 0x54,
+ 0x15, 0x51, 0x26, 0x2c, 0x45, 0x08, 0xf5, 0x0b,
+ 0x54, 0x24, 0x61, 0x4d, 0x7d, 0x52, 0x28, 0xa8,
+ 0xfc, 0x2d, 0xf6, 0x90, 0xe6, 0x9c, 0x08, 0x30,
+ 0x60, 0xa8, 0xe2, 0xc7, 0xb4, 0x14, 0x93, 0x4a,
+ 0xbf, 0xf3, 0xe6, 0xf9, 0x26, 0x39, 0x7f, 0x68,
+ 0x09, 0xd4, 0x79, 0x28, 0xe1, 0xc0, 0x26, 0x71,
+ 0x92, 0x9d, 0xef, 0xc9, 0x96, 0x89, 0xc7, 0x3e,
+ 0x01, 0x0b, 0x8d, 0x6a, 0x38, 0x31, 0xa3, 0x32,
+ 0xb5, 0xa8, 0xf8, 0x1f, 0x3a, 0x3c, 0x16, 0x17,
+ 0x1f, 0x9d, 0x4e, 0x18, 0xf8, 0x12, 0xd5, 0x07,
+ 0x96, 0x88, 0xdd, 0xc0, 0xa8, 0xdc, 0x90, 0xa9,
+ 0x81, 0x85, 0xb1, 0x2f, 0xd1, 0x1e, 0xe9, 0xaf,
+ 0x1f, 0x31, 0xda, 0xe6, 0x6e, 0xa8, 0xd5, 0x6e,
+ 0x69, 0x65, 0x77, 0xde, 0xc2, 0x01, 0x27, 0x44,
+ 0x90, 0x95, 0x3c, 0xe5, 0x2c, 0x81, 0x82, 0xb0,
+ 0x32, 0x9a, 0xc1, 0x13, 0x02, 0xf9, 0xa8, 0x22,
+ 0x87, 0xb6, 0x44, 0xe1, 0xe1, 0x86, 0xc0, 0xc7,
+ 0xee, 0x26, 0x0c, 0xf3, 0xd8, 0x65, 0x50, 0x01,
+ 0x7d, 0x8b, 0xa0, 0xc9, 0x42, 0xb7, 0x0f, 0xb3,
+ 0x69, 0xc3, 0x2b, 0x38, 0x30, 0xbb, 0xa6, 0xf1,
+ 0x4d, 0x3d, 0x4c, 0xd2, 0xf6, 0x3d, 0xe0, 0xb1,
+ 0xc7, 0x9a, 0xaa, 0xd3, 0xcd, 0x61, 0x36, 0xcf,
+ 0xbe, 0x41, 0xbf, 0x5c, 0x4c, 0xf3, 0xf6, 0x5b,
+ 0x74, 0x92, 0xdc, 0xb8, 0xb4, 0xdb, 0x43, 0x17,
+ 0x76, 0xf9, 0x03, 0x1b, 0x4e, 0xf2, 0x0f, 0x74,
+ 0xc4, 0x47, 0x5d, 0x81, 0xae, 0xdb, 0x54, 0xaa,
+ 0xbc, 0xf3, 0x1b, 0xa0, 0x47, 0x51, 0x35, 0x09,
+ 0x95, 0xd1, 0xc6, 0x73, 0x8b, 0xa3, 0x0c, 0x53,
+ 0xa8, 0xe1, 0xb4, 0x30, 0xce, 0x69, 0x99, 0xe9,
+ 0xa2, 0xcd, 0x47, 0x64, 0xcf, 0x67, 0x2b, 0x14,
+ 0x56, 0x41, 0x4a, 0xc1, 0x48, 0xce, 0x48, 0x6d,
+ 0x07, 0x6d, 0x69, 0xff, 0xba, 0xac, 0xa7, 0x18,
+ 0x9a, 0x60, 0x1b, 0x76, 0x5e, 0x90, 0x63, 0xa4,
+ 0xbe, 0x63, 0x9f, 0xa1, 0x55, 0xf0, 0x86, 0x8e,
+ 0x85, 0xcc, 0xa8, 0x0b, 0xce, 0xc5, 0xae, 0x16,
+ 0x74, 0x1f, 0x2d, 0x17, 0xcb, 0xb8, 0x43, 0x1a,
+ 0x87, 0xc5, 0x9f, 0xc3, 0xc5, 0x62, 0xe9, 0xf3,
+ 0xe9, 0xc9, 0x1a, 0x36, 0x77, 0x36, 0x1f, 0x40,
+ 0x32, 0x5e, 0xc0, 0x27, 0xf5, 0x82, 0xf7, 0xae,
+ 0x92, 0xce, 0x55, 0x4f, 0x47, 0xed, 0x84, 0xa8,
+ 0x62, 0x4e, 0x3f, 0x9d, 0x12, 0xec, 0x1e, 0xbd,
+ 0x86, 0xc8, 0x7e, 0xbd, 0xf2, 0xa4, 0x67, 0x3a,
+ 0xb3, 0x2d, 0x32, 0xcb, 0xf1, 0x4d, 0x45, 0xb2,
+ 0x2b, 0x6b, 0xc8, 0xe7, 0xdb, 0xcf, 0xa1, 0x60,
+ 0xc7, 0xc8, 0x18, 0x75, 0xde, 0x9e, 0xc7, 0xbe,
+ 0x81, 0xe7, 0x81, 0x21, 0xe2, 0xf6, 0xb6, 0x8a,
+ 0xdd, 0xda, 0x6b, 0xfd, 0xf3, 0x7a, 0xf3, 0x79,
+ 0x73, 0xf9, 0x0b, 0xdf, 0xde, 0xdd, 0x7f, 0xbb,
+ 0xbe, 0xfa, 0xbe, 0xde, 0xf4, 0xe9, 0xaa, 0xe5,
+ 0x88, 0x4c, 0xef, 0xac, 0x81, 0xfe, 0xa1, 0xff,
+ 0xaa, 0xf7, 0x8d, 0xe5
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/clipping_mask.cpp b/src/mbgl/shaders/clipping_mask.cpp
index fb08d7cb00..772ef34fa8 100644
--- a/src/mbgl/shaders/clipping_mask.cpp
+++ b/src/mbgl/shaders/clipping_mask.cpp
@@ -1,27 +1,46 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/clipping_mask.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* clipping_mask::name = "clipping_mask";
-const char* clipping_mask::vertexSource = R"MBGL_SHADER(
-attribute vec2 a_pos;
-
-uniform mat4 u_matrix;
-
-void main() {
- gl_Position = u_matrix * vec4(a_pos, 0, 1);
-}
-
-)MBGL_SHADER";
-const char* clipping_mask::fragmentSource = R"MBGL_SHADER(
-void main() {
- gl_FragColor = vec4(1.0);
-}
-
-)MBGL_SHADER";
+const char* clipping_mask::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x4b, 0x2c, 0x29, 0x29, 0xca, 0x4c,
+ 0x2a, 0x2d, 0x49, 0x55, 0x28, 0x4b, 0x4d, 0x36,
+ 0x52, 0x48, 0x8c, 0x2f, 0xc8, 0x2f, 0xb6, 0xe6,
+ 0xe2, 0x2a, 0xcd, 0xcb, 0x4c, 0xcb, 0x2f, 0xca,
+ 0x55, 0xc8, 0x4d, 0x2c, 0x31, 0x51, 0x28, 0x8d,
+ 0x07, 0x52, 0x45, 0x99, 0x15, 0x40, 0xf1, 0xb2,
+ 0xfc, 0xcc, 0x14, 0xa0, 0x60, 0x66, 0x9e, 0x86,
+ 0xa6, 0x42, 0x35, 0x97, 0x02, 0x10, 0xa4, 0xe7,
+ 0xc4, 0x07, 0xe4, 0x17, 0x67, 0x96, 0x64, 0xe6,
+ 0xe7, 0x29, 0xd8, 0xc2, 0x95, 0x2a, 0x68, 0x81,
+ 0xcc, 0x33, 0xd1, 0x00, 0x9b, 0xa7, 0xa3, 0x60,
+ 0xa0, 0xa3, 0x60, 0xa8, 0x69, 0xcd, 0x55, 0xcb,
+ 0x05, 0x00, 0x45, 0x7b, 0x23, 0xb2
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* clipping_mask::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x2b, 0xcb, 0xcf, 0x4c, 0x51, 0xc8,
+ 0x4d, 0xcc, 0xcc, 0xd3, 0xd0, 0x54, 0xa8, 0xe6,
+ 0x52, 0x00, 0x82, 0xf4, 0x9c, 0x78, 0xb7, 0xa2,
+ 0xc4, 0x74, 0xe7, 0xfc, 0x9c, 0xfc, 0x22, 0x05,
+ 0x5b, 0x85, 0xb2, 0xd4, 0x64, 0x13, 0x0d, 0x43,
+ 0x3d, 0x03, 0x4d, 0x6b, 0xae, 0x5a, 0x2e, 0x00,
+ 0x4c, 0x3f, 0x0d, 0x3a
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/collision_box.cpp b/src/mbgl/shaders/collision_box.cpp
index bc5d9bc6f9..5ac0f1e145 100644
--- a/src/mbgl/shaders/collision_box.cpp
+++ b/src/mbgl/shaders/collision_box.cpp
@@ -1,63 +1,100 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/collision_box.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* collision_box::name = "collision_box";
-const char* collision_box::vertexSource = R"MBGL_SHADER(
-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;
-}
-
-)MBGL_SHADER";
-const char* collision_box::fragmentSource = R"MBGL_SHADER(
-
-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;
- }
-}
-)MBGL_SHADER";
+const char* collision_box::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x7d, 0x52, 0xcb, 0x6e, 0xc2, 0x30,
+ 0x10, 0xbc, 0xe7, 0x2b, 0xf6, 0xc8, 0xab, 0x09,
+ 0x54, 0xf4, 0x14, 0xf1, 0x0f, 0x5c, 0x7a, 0xb6,
+ 0x8c, 0xb3, 0xc0, 0x56, 0x8e, 0x37, 0xb2, 0x9d,
+ 0x10, 0xa8, 0xfa, 0xef, 0x5d, 0xd2, 0x10, 0x28,
+ 0x02, 0x7c, 0x48, 0xe4, 0x9d, 0x99, 0xdd, 0xf1,
+ 0x68, 0x75, 0x8c, 0x9e, 0x36, 0x75, 0x44, 0x68,
+ 0xd0, 0xbc, 0x83, 0x56, 0x15, 0x87, 0x3c, 0xd1,
+ 0xf7, 0x55, 0xed, 0xcc, 0x9e, 0xfd, 0x13, 0x10,
+ 0xdb, 0xe8, 0xeb, 0x02, 0x1f, 0x20, 0x95, 0xd5,
+ 0x06, 0x8b, 0x3c, 0x49, 0x6a, 0x47, 0x5b, 0xf6,
+ 0x25, 0x94, 0x3a, 0x2e, 0xa1, 0x56, 0xf2, 0xf3,
+ 0xd4, 0xe6, 0x43, 0xb9, 0xa3, 0xd7, 0x97, 0x46,
+ 0x2a, 0x18, 0x6d, 0xf1, 0x8a, 0x6e, 0x2d, 0xeb,
+ 0x28, 0xb0, 0xd1, 0x25, 0x7a, 0xad, 0x22, 0x2b,
+ 0x83, 0x2e, 0xa2, 0x57, 0x05, 0x85, 0x28, 0xce,
+ 0x84, 0x9a, 0x34, 0xda, 0x1f, 0xc9, 0xed, 0x7a,
+ 0x6e, 0x33, 0x4c, 0xbe, 0xaf, 0x3b, 0x8e, 0x9f,
+ 0xa1, 0xb3, 0xd4, 0x30, 0x15, 0xe2, 0x87, 0xdc,
+ 0x68, 0x0c, 0xdf, 0x09, 0xc8, 0x11, 0x17, 0x4b,
+ 0xa8, 0x3c, 0x7f, 0xa1, 0x89, 0x58, 0xac, 0x99,
+ 0x5c, 0x84, 0xd5, 0xe0, 0x16, 0x26, 0x1d, 0x61,
+ 0x74, 0x1b, 0xc6, 0x0c, 0xe6, 0x33, 0x58, 0x8c,
+ 0xf3, 0x4e, 0xbe, 0xa7, 0xdd, 0xbe, 0xea, 0x07,
+ 0x5d, 0xad, 0xf6, 0xe4, 0x8b, 0x55, 0x69, 0xf8,
+ 0x7f, 0x42, 0x7a, 0x78, 0xa0, 0x66, 0x6b, 0x29,
+ 0x10, 0x3b, 0x55, 0xa1, 0x0f, 0x95, 0x90, 0xa9,
+ 0x41, 0xe5, 0x75, 0x24, 0x16, 0xbd, 0xb1, 0xba,
+ 0xac, 0x46, 0x9d, 0xe8, 0x7c, 0xe6, 0xe9, 0x07,
+ 0x4c, 0xbb, 0xef, 0x04, 0x46, 0x2f, 0x42, 0x82,
+ 0xec, 0xb9, 0xab, 0xf1, 0xec, 0xa6, 0x9d, 0x3c,
+ 0x29, 0xcb, 0x60, 0xed, 0xb1, 0x91, 0x06, 0x01,
+ 0xb8, 0x11, 0x0f, 0x74, 0xc2, 0x02, 0x1c, 0x6a,
+ 0xff, 0xb6, 0x25, 0xb4, 0x05, 0x6c, 0xb8, 0xc5,
+ 0x00, 0xe4, 0xa0, 0xa2, 0x68, 0xf6, 0x58, 0x64,
+ 0x67, 0xd6, 0x89, 0xb9, 0x14, 0x5a, 0x24, 0x8b,
+ 0x61, 0xe8, 0xb7, 0x4c, 0xe7, 0x92, 0x4f, 0x77,
+ 0xdd, 0x59, 0xb5, 0xe6, 0x40, 0xf2, 0x0a, 0xf7,
+ 0x30, 0xd7, 0xbf, 0x40, 0xcf, 0xf3, 0x17, 0x9d,
+ 0xe8, 0x4e, 0x93, 0xb6, 0x47, 0x98, 0xae, 0xae,
+ 0xfb, 0x26, 0xc2, 0xbb, 0x95, 0x91, 0xca, 0x2d,
+ 0xff, 0x20, 0xf7, 0x17, 0x51, 0xf6, 0xae, 0x2e,
+ 0xbb, 0x02, 0xab, 0x61, 0x61, 0xd3, 0x36, 0xef,
+ 0xa1, 0x7e, 0x5d, 0x6e, 0xb1, 0x63, 0x9e, 0xfc,
+ 0x24, 0xbf, 0xdf, 0xcb, 0x16, 0xcc
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* collision_box::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x6d, 0x90, 0xc1, 0x4e, 0xc3, 0x40,
+ 0x0c, 0x44, 0xef, 0xfb, 0x15, 0x73, 0x4c, 0xab,
+ 0x28, 0x6d, 0x25, 0x38, 0x55, 0xe5, 0x00, 0x12,
+ 0x1f, 0x80, 0xe0, 0x5c, 0xb9, 0xc9, 0x26, 0xb1,
+ 0x64, 0xd6, 0x55, 0xb2, 0x09, 0x20, 0xd4, 0x7f,
+ 0xc7, 0x49, 0x1a, 0x28, 0x50, 0x1f, 0x56, 0xda,
+ 0xd9, 0xf1, 0xf8, 0xad, 0x5d, 0x4f, 0xcd, 0x07,
+ 0x87, 0x0a, 0xa5, 0x28, 0x45, 0xf4, 0xfb, 0xa3,
+ 0x50, 0xee, 0x8b, 0xad, 0xfb, 0xab, 0x07, 0x8d,
+ 0x2f, 0xed, 0xf0, 0xe0, 0x7a, 0xe5, 0x02, 0xaf,
+ 0xc4, 0x21, 0x59, 0xe0, 0xd3, 0x39, 0x58, 0x4d,
+ 0x26, 0x92, 0x63, 0x4d, 0xd8, 0x61, 0x9d, 0xdd,
+ 0x6e, 0x27, 0x7d, 0xb5, 0xc2, 0x93, 0x2f, 0x4c,
+ 0xca, 0x55, 0x84, 0x5b, 0xd6, 0x90, 0xa2, 0xe6,
+ 0xc2, 0x43, 0xe8, 0xe0, 0x65, 0xb4, 0x54, 0xb2,
+ 0x7f, 0x6c, 0xa8, 0x7a, 0x50, 0xd1, 0xc6, 0x8c,
+ 0xbd, 0xcf, 0x6f, 0x92, 0x4d, 0xb6, 0x4e, 0x2d,
+ 0x65, 0x3e, 0xec, 0xba, 0xc0, 0x72, 0x8a, 0xff,
+ 0x09, 0xbe, 0x97, 0xce, 0x5b, 0x43, 0xd0, 0xcb,
+ 0xf0, 0x31, 0x17, 0xdc, 0xa2, 0xad, 0xf5, 0xcd,
+ 0xf0, 0x47, 0x33, 0x97, 0x48, 0xe6, 0x8f, 0xe1,
+ 0x6e, 0xc0, 0x1b, 0xc0, 0x71, 0xae, 0x6b, 0x00,
+ 0xbf, 0x66, 0xa7, 0x53, 0xc7, 0x37, 0xc0, 0xd0,
+ 0x74, 0x72, 0x17, 0xc9, 0xe7, 0xd5, 0xfc, 0x8f,
+ 0x36, 0xca, 0xe7, 0xda, 0x60, 0x0e, 0xfa, 0x6e,
+ 0x9c, 0x11, 0x9d, 0xb9, 0x52, 0x94, 0x64, 0x0b,
+ 0xe0, 0x08, 0xed, 0xe2, 0x75, 0x88, 0xe5, 0x0e,
+ 0xd9, 0x66, 0x9e, 0x73, 0xfa, 0x02, 0x88, 0x26,
+ 0x74, 0x25
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/collision_circle.cpp b/src/mbgl/shaders/collision_circle.cpp
index 82ebbf05a0..4742ba9360 100644
--- a/src/mbgl/shaders/collision_circle.cpp
+++ b/src/mbgl/shaders/collision_circle.cpp
@@ -1,87 +1,140 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/collision_circle.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* collision_circle::name = "collision_circle";
-const char* collision_circle::vertexSource = R"MBGL_SHADER(
-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;
-}
-
-)MBGL_SHADER";
-const char* collision_circle::fragmentSource = R"MBGL_SHADER(
-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;
-}
-
-)MBGL_SHADER";
+const char* collision_circle::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x85, 0x53, 0x4d, 0x93, 0xda, 0x30,
+ 0x0c, 0xbd, 0xe7, 0x57, 0xe8, 0x56, 0x60, 0xd9,
+ 0x00, 0x3b, 0xf4, 0x94, 0xe1, 0x3f, 0x70, 0xe9,
+ 0xf4, 0x98, 0x11, 0xb6, 0x01, 0x6d, 0x1d, 0x3b,
+ 0xb5, 0x9d, 0x2c, 0x6c, 0xa7, 0xff, 0xbd, 0xb2,
+ 0x49, 0xc2, 0xc7, 0x64, 0x69, 0x0e, 0xc9, 0x44,
+ 0x7a, 0x92, 0xdf, 0x7b, 0x92, 0x31, 0x04, 0x47,
+ 0xbb, 0x26, 0x28, 0x68, 0x95, 0x78, 0x03, 0x2c,
+ 0x6b, 0xeb, 0x8b, 0x0c, 0x1f, 0xa3, 0x68, 0xc4,
+ 0xd1, 0xba, 0x2f, 0x92, 0xea, 0x14, 0x5c, 0x23,
+ 0xd5, 0x48, 0xa6, 0xd6, 0x28, 0x94, 0x2c, 0xb2,
+ 0xac, 0x31, 0xb4, 0xb7, 0xae, 0x82, 0x0a, 0xc3,
+ 0x1a, 0x9a, 0x92, 0x3f, 0x8e, 0x4e, 0xc5, 0x10,
+ 0x4e, 0xf0, 0xa6, 0x6f, 0x54, 0x7a, 0x81, 0x5a,
+ 0x5d, 0xb3, 0x7b, 0x6d, 0x31, 0x70, 0x5a, 0x60,
+ 0xa5, 0x1c, 0x96, 0xc1, 0x96, 0x42, 0x99, 0xa0,
+ 0x5c, 0x29, 0xc9, 0x07, 0x66, 0xc6, 0xd0, 0xac,
+ 0x45, 0x77, 0x26, 0x73, 0xe8, 0xb0, 0xed, 0x70,
+ 0xf2, 0x63, 0xdc, 0xd8, 0xf0, 0xc3, 0x8f, 0x25,
+ 0x1c, 0x4a, 0x6a, 0xfc, 0x4d, 0xa7, 0xc4, 0xa9,
+ 0xbd, 0x8a, 0x1b, 0x8f, 0xf7, 0x5c, 0xb3, 0xd6,
+ 0x92, 0x64, 0x79, 0x64, 0x26, 0x53, 0xf8, 0x93,
+ 0x01, 0x3f, 0x0c, 0x5c, 0x43, 0xed, 0xec, 0xbb,
+ 0x12, 0x41, 0xc9, 0xad, 0x25, 0x13, 0x60, 0x33,
+ 0x88, 0x87, 0x59, 0x02, 0x4c, 0x6e, 0xbd, 0x9d,
+ 0xc3, 0x72, 0x0e, 0xab, 0x69, 0x91, 0xca, 0x8f,
+ 0x74, 0x38, 0xd6, 0x1d, 0xbd, 0xab, 0xf2, 0x0e,
+ 0xdc, 0x2b, 0xe7, 0x86, 0xf7, 0x27, 0xe4, 0x1f,
+ 0x23, 0xd5, 0x56, 0x6b, 0xf2, 0x64, 0x4d, 0x59,
+ 0x2b, 0xe7, 0x6b, 0x06, 0x53, 0xab, 0x58, 0x70,
+ 0x20, 0xcb, 0xf5, 0x42, 0x63, 0x55, 0x4f, 0x52,
+ 0x51, 0x7c, 0x96, 0xf9, 0x77, 0x78, 0x49, 0xef,
+ 0x19, 0x4c, 0x9e, 0x78, 0x0e, 0x8b, 0xaf, 0x59,
+ 0x4d, 0xe7, 0x37, 0xed, 0x58, 0xd2, 0x62, 0x01,
+ 0x5b, 0xa7, 0x5a, 0x6e, 0xe0, 0xc1, 0xb6, 0xcc,
+ 0x81, 0x3e, 0x95, 0x04, 0xa3, 0xd0, 0xbd, 0xee,
+ 0x49, 0x69, 0x09, 0x82, 0x9c, 0xd0, 0xca, 0x03,
+ 0x19, 0xa8, 0x29, 0x88, 0xa3, 0x92, 0x8b, 0x88,
+ 0xfb, 0xb4, 0xb6, 0x62, 0x60, 0x20, 0xce, 0x0d,
+ 0x1d, 0xd7, 0xf9, 0x92, 0x1d, 0x4a, 0xbf, 0x07,
+ 0x5d, 0x6e, 0xad, 0x27, 0xd6, 0x61, 0x46, 0x9d,
+ 0xbd, 0x58, 0x1a, 0x19, 0xac, 0xae, 0x45, 0xb7,
+ 0xce, 0xd4, 0x28, 0x25, 0xcf, 0xb4, 0xdc, 0xa3,
+ 0x08, 0xd6, 0x71, 0x8f, 0x55, 0xfe, 0x56, 0x24,
+ 0xba, 0xc8, 0xc7, 0x1e, 0xe3, 0x1e, 0xbb, 0x40,
+ 0x82, 0x99, 0x79, 0xcd, 0x65, 0x41, 0x9f, 0x21,
+ 0x58, 0x9e, 0xf2, 0x2f, 0x05, 0x8e, 0xb9, 0x01,
+ 0xaf, 0x27, 0xa0, 0x09, 0xf4, 0x8a, 0x9a, 0xd0,
+ 0xc3, 0x4e, 0x37, 0xee, 0x91, 0x58, 0x7e, 0x3a,
+ 0xc3, 0xcb, 0xe6, 0x7a, 0x4b, 0x98, 0xdd, 0xc3,
+ 0xa2, 0x73, 0xe4, 0x81, 0xc7, 0xec, 0xae, 0xc1,
+ 0x07, 0xff, 0x3f, 0x19, 0x61, 0x27, 0xab, 0x5f,
+ 0x79, 0xd8, 0x0c, 0xf7, 0x2e, 0x3f, 0x15, 0x5d,
+ 0xaa, 0xdb, 0xfa, 0xdb, 0xdc, 0xb9, 0xcf, 0x5d,
+ 0x16, 0x3f, 0xa6, 0x76, 0x7e, 0x32, 0xd0, 0xcc,
+ 0xcf, 0xd3, 0x64, 0xc4, 0x4f, 0x05, 0xd2, 0x9a,
+ 0x6f, 0xe1, 0x32, 0x97, 0xe4, 0x49, 0x37, 0xac,
+ 0x39, 0x78, 0x0b, 0x3b, 0x1b, 0x8e, 0xc0, 0xf7,
+ 0x34, 0x0e, 0x76, 0x9f, 0xb2, 0xa9, 0x3e, 0x32,
+ 0x8d, 0x43, 0x88, 0x62, 0xd0, 0x71, 0xf0, 0x77,
+ 0x83, 0x3a, 0x4e, 0xb7, 0xc2, 0x03, 0x83, 0xa3,
+ 0x0d, 0xec, 0x63, 0x84, 0x5f, 0x4e, 0xef, 0x25,
+ 0xf4, 0x1e, 0xdd, 0xfb, 0x75, 0xef, 0x4e, 0x71,
+ 0x8f, 0xed, 0x3c, 0xdc, 0x8c, 0xb8, 0xfa, 0x6c,
+ 0x7b, 0xff, 0x63, 0xe9, 0xdf, 0xec, 0x1f, 0x57,
+ 0xdf, 0xc0, 0xf4
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* collision_circle::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x75, 0x52, 0xcb, 0x6e, 0x83, 0x30,
+ 0x10, 0xbc, 0xf3, 0x15, 0x7b, 0x84, 0x88, 0x3c,
+ 0xd5, 0x9c, 0xa2, 0xf4, 0xd0, 0x4a, 0xfd, 0x80,
+ 0xaa, 0x3d, 0x5b, 0x0e, 0x36, 0x60, 0xd5, 0x61,
+ 0x91, 0x6d, 0x48, 0xa2, 0x2a, 0xff, 0xde, 0x35,
+ 0x90, 0xf2, 0x48, 0xe2, 0x03, 0xc2, 0xeb, 0xd9,
+ 0x99, 0xd9, 0x47, 0x55, 0xa8, 0x14, 0xcd, 0x11,
+ 0x52, 0x8d, 0xdc, 0x41, 0xc5, 0xb0, 0x96, 0xc6,
+ 0x26, 0x5c, 0x4b, 0x96, 0xf2, 0xc4, 0xa1, 0xd9,
+ 0x05, 0x41, 0xcd, 0xcd, 0x45, 0x15, 0x59, 0x07,
+ 0xa9, 0x59, 0xa9, 0x79, 0x22, 0xc5, 0xee, 0x2e,
+ 0x5e, 0xa0, 0xfb, 0xb6, 0x8f, 0x1e, 0x0c, 0x17,
+ 0xaa, 0xb2, 0x7d, 0xbc, 0x96, 0xc9, 0x86, 0xc2,
+ 0xf2, 0xec, 0x4c, 0x25, 0xe4, 0xb3, 0x38, 0x6b,
+ 0x6c, 0x78, 0x7d, 0x54, 0x02, 0x8e, 0x5c, 0x15,
+ 0x61, 0x04, 0xbf, 0x01, 0xd0, 0x69, 0x89, 0xb9,
+ 0x2e, 0x73, 0x0e, 0x7b, 0x58, 0x2d, 0xb6, 0x84,
+ 0xf2, 0xf1, 0xe5, 0x12, 0x3e, 0xa5, 0xa0, 0x50,
+ 0x82, 0x5a, 0x2b, 0xab, 0xb0, 0x88, 0x21, 0x57,
+ 0x42, 0x82, 0xe6, 0x07, 0xa9, 0x1b, 0x08, 0x69,
+ 0xbc, 0xf8, 0x67, 0x34, 0x04, 0xf3, 0x97, 0x70,
+ 0xbd, 0x58, 0xc5, 0xc4, 0x71, 0xfb, 0xd0, 0x35,
+ 0x82, 0x59, 0x4b, 0xde, 0xd3, 0xbe, 0xe9, 0x4a,
+ 0x52, 0x42, 0x81, 0x43, 0xea, 0x86, 0x15, 0x94,
+ 0x05, 0x9b, 0xe3, 0x89, 0x0a, 0x68, 0xc0, 0x2a,
+ 0x85, 0xf0, 0xd6, 0x23, 0x78, 0xf5, 0xe6, 0x6e,
+ 0xae, 0xfd, 0x19, 0x29, 0x8f, 0x44, 0xe3, 0x16,
+ 0xfa, 0xaf, 0xec, 0xd1, 0xd7, 0x60, 0x40, 0xd9,
+ 0xb5, 0xf7, 0x9e, 0x93, 0xec, 0x7d, 0xe5, 0xe4,
+ 0xe2, 0x80, 0x67, 0x32, 0x48, 0x43, 0x24, 0x54,
+ 0x0c, 0x29, 0xa7, 0xba, 0x95, 0x03, 0xac, 0xdc,
+ 0x44, 0x7d, 0xb6, 0x87, 0xc5, 0x66, 0x24, 0xd0,
+ 0xf6, 0x73, 0xd4, 0x77, 0xa6, 0x65, 0x91, 0xb9,
+ 0x9c, 0xac, 0xb6, 0x3f, 0xe1, 0x64, 0x2e, 0xd1,
+ 0xee, 0x41, 0xe6, 0xd3, 0x1c, 0x5f, 0xd7, 0x23,
+ 0xfa, 0x21, 0x89, 0x75, 0x06, 0x7f, 0x24, 0x3b,
+ 0x29, 0xd1, 0x50, 0xac, 0xb7, 0x8b, 0xd5, 0x93,
+ 0x2c, 0x58, 0x3e, 0x5c, 0xd4, 0x9e, 0xaa, 0x5d,
+ 0x38, 0xdf, 0xe6, 0x6e, 0xf7, 0x9e, 0xca, 0x0f,
+ 0x92, 0x84, 0xb2, 0x8e, 0x17, 0x89, 0x64, 0x0e,
+ 0x99, 0x14, 0x99, 0x1f, 0x37, 0x3f, 0xd8, 0x70,
+ 0x52, 0xdb, 0xbc, 0x23, 0x1f, 0xd5, 0x8f, 0x25,
+ 0x4f, 0x94, 0xbb, 0x30, 0x47, 0x39, 0xf6, 0x88,
+ 0xe8, 0x72, 0xeb, 0x64, 0x19, 0xce, 0x87, 0x25,
+ 0x75, 0x93, 0x9e, 0x4f, 0x65, 0xa2, 0xce, 0x44,
+ 0xa6, 0xd9, 0x87, 0xe1, 0xd9, 0x7b, 0xb7, 0x20,
+ 0x3d, 0xe5, 0xac, 0x1d, 0xdb, 0x2e, 0xb8, 0x06,
+ 0x7f, 0x6e, 0x86, 0x2b, 0x59
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/debug.cpp b/src/mbgl/shaders/debug.cpp
index 9012cfa755..9294ae9e26 100644
--- a/src/mbgl/shaders/debug.cpp
+++ b/src/mbgl/shaders/debug.cpp
@@ -1,29 +1,48 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/debug.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* debug::name = "debug";
-const char* debug::vertexSource = R"MBGL_SHADER(
-attribute vec2 a_pos;
-
-uniform mat4 u_matrix;
-
-void main() {
- gl_Position = u_matrix * vec4(a_pos, 0, 1);
-}
-
-)MBGL_SHADER";
-const char* debug::fragmentSource = R"MBGL_SHADER(
-uniform highp vec4 u_color;
-
-void main() {
- gl_FragColor = u_color;
-}
-
-)MBGL_SHADER";
+const char* debug::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x4b, 0x2c, 0x29, 0x29, 0xca, 0x4c,
+ 0x2a, 0x2d, 0x49, 0x55, 0x28, 0x4b, 0x4d, 0x36,
+ 0x52, 0x48, 0x8c, 0x2f, 0xc8, 0x2f, 0xb6, 0xe6,
+ 0xe2, 0x2a, 0xcd, 0xcb, 0x4c, 0xcb, 0x2f, 0xca,
+ 0x55, 0xc8, 0x4d, 0x2c, 0x31, 0x51, 0x28, 0x8d,
+ 0x07, 0x52, 0x45, 0x99, 0x15, 0x40, 0xf1, 0xb2,
+ 0xfc, 0xcc, 0x14, 0xa0, 0x60, 0x66, 0x9e, 0x86,
+ 0xa6, 0x42, 0x35, 0x97, 0x02, 0x10, 0xa4, 0xe7,
+ 0xc4, 0x07, 0xe4, 0x17, 0x67, 0x96, 0x64, 0xe6,
+ 0xe7, 0x29, 0xd8, 0xc2, 0x95, 0x2a, 0x68, 0x81,
+ 0xcc, 0x33, 0xd1, 0x00, 0x9b, 0xa7, 0xa3, 0x60,
+ 0xa0, 0xa3, 0x60, 0xa8, 0x69, 0xcd, 0x55, 0xcb,
+ 0x05, 0x00, 0x45, 0x7b, 0x23, 0xb2
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* debug::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x2b, 0xcd, 0xcb, 0x4c, 0xcb, 0x2f,
+ 0xca, 0x55, 0xc8, 0xc8, 0x4c, 0xcf, 0x28, 0x50,
+ 0x28, 0x4b, 0x4d, 0x36, 0x51, 0x28, 0x8d, 0x4f,
+ 0xce, 0xcf, 0xc9, 0x2f, 0xb2, 0xe6, 0xe2, 0x2a,
+ 0xcb, 0xcf, 0x4c, 0x51, 0xc8, 0x4d, 0xcc, 0xcc,
+ 0xd3, 0xd0, 0x54, 0xa8, 0xe6, 0x52, 0x00, 0x82,
+ 0xf4, 0x9c, 0x78, 0xb7, 0xa2, 0xc4, 0x74, 0x67,
+ 0x90, 0x02, 0x05, 0x5b, 0x84, 0xd2, 0x5a, 0x2e,
+ 0x00, 0x9b, 0x4e, 0x17, 0xff
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/extrusion_texture.cpp b/src/mbgl/shaders/extrusion_texture.cpp
index c756db181c..2a9b0909af 100644
--- a/src/mbgl/shaders/extrusion_texture.cpp
+++ b/src/mbgl/shaders/extrusion_texture.cpp
@@ -1,39 +1,66 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/extrusion_texture.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* extrusion_texture::name = "extrusion_texture";
-const char* extrusion_texture::vertexSource = R"MBGL_SHADER(
-uniform mat4 u_matrix;
-uniform vec2 u_world;
-attribute vec2 a_pos;
-varying vec2 v_pos;
-
-void main() {
- gl_Position = u_matrix * vec4(a_pos * u_world, 0, 1);
-
- v_pos.x = a_pos.x;
- v_pos.y = 1.0 - a_pos.y;
-}
-
-)MBGL_SHADER";
-const char* extrusion_texture::fragmentSource = R"MBGL_SHADER(
-uniform sampler2D u_image;
-uniform float u_opacity;
-varying vec2 v_pos;
-
-void main() {
- gl_FragColor = texture2D(u_image, v_pos) * u_opacity;
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(0.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* extrusion_texture::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x4d, 0x8d, 0x41, 0x0a, 0x83, 0x30,
+ 0x10, 0x45, 0xf7, 0x73, 0x8a, 0x59, 0x6a, 0xb1,
+ 0xa2, 0xc5, 0x5d, 0xe8, 0x1d, 0x7a, 0x83, 0x90,
+ 0x56, 0x2b, 0x03, 0x9a, 0x94, 0x98, 0x44, 0x43,
+ 0xe9, 0xdd, 0x3b, 0x9a, 0x50, 0x3a, 0x9b, 0x99,
+ 0x79, 0x9f, 0xff, 0xbf, 0xd7, 0xf4, 0x34, 0x76,
+ 0xc6, 0x59, 0xb9, 0x0e, 0xbd, 0xe4, 0x65, 0x69,
+ 0x13, 0xe0, 0x33, 0x0e, 0xc3, 0xe3, 0xc2, 0x78,
+ 0x35, 0x76, 0xea, 0x05, 0x28, 0xc7, 0xea, 0xdd,
+ 0xbb, 0x21, 0x71, 0x25, 0x5f, 0x66, 0x11, 0x10,
+ 0x94, 0x8d, 0xa4, 0xc7, 0xc4, 0x42, 0x62, 0x10,
+ 0x0c, 0xf5, 0x1c, 0x4a, 0xba, 0x28, 0xf1, 0x0d,
+ 0xc8, 0x33, 0x4e, 0xf2, 0x66, 0x16, 0x72, 0x64,
+ 0x34, 0x5e, 0x7f, 0x55, 0x78, 0xda, 0x7d, 0x5d,
+ 0x71, 0x64, 0xf1, 0x93, 0xbb, 0x2a, 0x6c, 0x2a,
+ 0x6c, 0x4b, 0x0e, 0xda, 0xad, 0x47, 0x68, 0xbd,
+ 0xb1, 0x4d, 0xa5, 0x4b, 0xfc, 0xe1, 0xc8, 0xb8,
+ 0xad, 0x1b, 0x3c, 0x67, 0x31, 0x0a, 0xf8, 0xc0,
+ 0x17, 0xe6, 0x77, 0x44, 0xb1
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* extrusion_texture::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x6d, 0x8e, 0xb1, 0x0a, 0xc2, 0x30,
+ 0x18, 0x84, 0xf7, 0xff, 0x29, 0x7e, 0xe8, 0xd2,
+ 0x8a, 0x48, 0x29, 0x6e, 0xc1, 0x41, 0x6c, 0x05,
+ 0x17, 0x2b, 0x55, 0x74, 0x0c, 0xa1, 0x4d, 0x42,
+ 0x20, 0x69, 0x4a, 0x9a, 0x04, 0x8b, 0xf8, 0xee,
+ 0x16, 0xec, 0xe0, 0xe0, 0x8d, 0x77, 0xdc, 0x77,
+ 0x17, 0x7a, 0x25, 0xac, 0x33, 0x38, 0x32, 0x33,
+ 0x68, 0xee, 0x8a, 0x12, 0x03, 0x55, 0x86, 0x49,
+ 0x4e, 0x20, 0x2c, 0x91, 0xd0, 0x96, 0xf9, 0xd9,
+ 0xb6, 0x03, 0x6b, 0x95, 0x9f, 0x08, 0x44, 0xe6,
+ 0x26, 0xd5, 0x4b, 0x8c, 0xbc, 0x2d, 0x30, 0xd2,
+ 0xc1, 0x8e, 0x04, 0x20, 0x5a, 0xd5, 0xa1, 0x61,
+ 0xaa, 0x4f, 0x33, 0x7c, 0x01, 0xce, 0x92, 0x9a,
+ 0x1e, 0x1d, 0x93, 0x07, 0xab, 0xad, 0xc3, 0x1d,
+ 0x7a, 0xfe, 0xf4, 0xc1, 0xf1, 0xa2, 0x4c, 0x97,
+ 0x85, 0xf5, 0xb7, 0x9b, 0xe1, 0xea, 0x17, 0x0e,
+ 0x89, 0x12, 0x1d, 0x17, 0x58, 0xdf, 0xab, 0xa6,
+ 0x6c, 0xf6, 0x0f, 0x7a, 0x3a, 0x5f, 0x2f, 0xd5,
+ 0xe1, 0x56, 0x37, 0xff, 0xa0, 0xf3, 0x85, 0x6d,
+ 0x9a, 0x6f, 0xf2, 0x8c, 0x40, 0xc2, 0xfb, 0x4e,
+ 0x09, 0x78, 0xc3, 0x07, 0x17, 0x5e, 0x44, 0xe1
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/fill.cpp b/src/mbgl/shaders/fill.cpp
index 3ba00836a2..12aa31237b 100644
--- a/src/mbgl/shaders/fill.cpp
+++ b/src/mbgl/shaders/fill.cpp
@@ -1,91 +1,88 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/fill.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* fill::name = "fill";
-const char* fill::vertexSource = R"MBGL_SHADER(
-attribute vec2 a_pos;
-
-uniform mat4 u_matrix;
-
-
-#ifndef HAS_UNIFORM_u_color
-uniform lowp float a_color_t;
-attribute highp vec4 a_color;
-varying highp vec4 color;
-#else
-uniform highp vec4 u_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-uniform lowp float a_opacity_t;
-attribute lowp vec2 a_opacity;
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-void main() {
-
-#ifndef HAS_UNIFORM_u_color
- color = unpack_mix_vec4(a_color, a_color_t);
-#else
- highp vec4 color = u_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
- opacity = unpack_mix_vec2(a_opacity, a_opacity_t);
-#else
- lowp float opacity = u_opacity;
-#endif
-
-
- gl_Position = u_matrix * vec4(a_pos, 0, 1);
-}
-
-)MBGL_SHADER";
-const char* fill::fragmentSource = R"MBGL_SHADER(
-
-#ifndef HAS_UNIFORM_u_color
-varying highp vec4 color;
-#else
-uniform highp vec4 u_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_color
- highp vec4 color = u_color;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_opacity
- lowp float opacity = u_opacity;
-#endif
-
-
- gl_FragColor = color * opacity;
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* fill::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x7d, 0x92, 0x3f, 0x4f, 0xc3, 0x30,
+ 0x10, 0xc5, 0x77, 0x7f, 0x8a, 0x93, 0xba, 0xa4,
+ 0x28, 0x03, 0x54, 0xdd, 0x22, 0x06, 0x16, 0x04,
+ 0x03, 0x7f, 0x04, 0x62, 0x3e, 0x99, 0x24, 0x4e,
+ 0x4f, 0x24, 0x76, 0x94, 0xd8, 0xa1, 0x15, 0xe2,
+ 0xbb, 0x63, 0x07, 0xc7, 0x75, 0x1a, 0xa8, 0x17,
+ 0x5b, 0x7e, 0xef, 0xee, 0x9e, 0x7f, 0x32, 0xd7,
+ 0xba, 0xa3, 0x77, 0xa3, 0x4b, 0x18, 0xca, 0x7c,
+ 0x03, 0x1c, 0x5b, 0xd5, 0x67, 0x8c, 0x19, 0x49,
+ 0x42, 0x75, 0x0d, 0x34, 0x5c, 0x6f, 0xc1, 0xa0,
+ 0xdd, 0x3a, 0xda, 0xdb, 0x7b, 0xb6, 0x22, 0x21,
+ 0x8b, 0x52, 0xc0, 0xdd, 0xcd, 0x2b, 0xbe, 0x3d,
+ 0xde, 0xdf, 0x3e, 0xbd, 0x3c, 0xa0, 0xc1, 0x5c,
+ 0xd5, 0xaa, 0x0b, 0x45, 0xb5, 0xfa, 0x6c, 0x41,
+ 0xd4, 0x8a, 0x6b, 0xdb, 0x6f, 0x94, 0x50, 0x67,
+ 0x8c, 0x87, 0x49, 0x3b, 0xaa, 0x76, 0xad, 0x9b,
+ 0xb7, 0x9d, 0xf4, 0x8c, 0x0d, 0xbc, 0x3b, 0x90,
+ 0xac, 0x62, 0xcd, 0x2b, 0xab, 0xb2, 0xee, 0xcb,
+ 0xd0, 0x3b, 0xd2, 0x0d, 0x06, 0x87, 0x2c, 0x48,
+ 0xfc, 0x1b, 0x4e, 0xb5, 0x3c, 0x27, 0x7d, 0xf8,
+ 0x3b, 0x9e, 0x17, 0xe7, 0x01, 0x47, 0x87, 0xe7,
+ 0xe1, 0x0d, 0xc7, 0x84, 0x51, 0x79, 0xd0, 0xe6,
+ 0x19, 0x23, 0x87, 0xc1, 0xc8, 0xe3, 0x53, 0x0e,
+ 0x8a, 0x0a, 0x0b, 0x96, 0x64, 0xb2, 0x86, 0x2f,
+ 0x06, 0x76, 0x9d, 0xa5, 0xea, 0x0c, 0xe3, 0x09,
+ 0xae, 0xc1, 0x48, 0xdb, 0xed, 0x03, 0x1b, 0xda,
+ 0xa3, 0x43, 0x90, 0x78, 0x7c, 0xe9, 0x91, 0xf3,
+ 0x7a, 0x0a, 0xe3, 0xca, 0x4e, 0x61, 0xba, 0x0e,
+ 0xa7, 0xd0, 0xce, 0xcc, 0x9f, 0xc0, 0x39, 0x8b,
+ 0x3f, 0x2f, 0x32, 0x6c, 0x92, 0x80, 0x28, 0x8d,
+ 0x71, 0xce, 0x72, 0x2c, 0x91, 0x8d, 0x49, 0x96,
+ 0x68, 0x9c, 0xb9, 0xaa, 0xf1, 0x59, 0xf5, 0xa4,
+ 0x49, 0xc9, 0xd1, 0xf5, 0xfb, 0xf7, 0xe0, 0x02,
+ 0xfc, 0x8b, 0xed, 0x07, 0x4d, 0xe1, 0x32, 0x85,
+ 0x2b, 0x3b, 0xe2, 0x9b, 0xfd, 0x00, 0x83, 0x90,
+ 0xec, 0xfc
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* fill::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x75, 0x8f, 0x4f, 0x0b, 0x82, 0x40,
+ 0x14, 0xc4, 0xef, 0xef, 0x53, 0x3c, 0xf0, 0x62,
+ 0x1d, 0xa2, 0xa0, 0x5b, 0x74, 0x10, 0x4b, 0xf2,
+ 0x50, 0x86, 0xf6, 0xe7, 0xb8, 0x2c, 0xea, 0xea,
+ 0xc2, 0xb6, 0x2b, 0xa6, 0x46, 0x44, 0xdf, 0xbd,
+ 0xb6, 0xcc, 0x24, 0xed, 0x5d, 0x67, 0xe6, 0xfd,
+ 0x66, 0xc0, 0xe0, 0x4c, 0x46, 0x31, 0xc3, 0x95,
+ 0x15, 0x90, 0xfd, 0xc6, 0x75, 0x3c, 0x7f, 0x4d,
+ 0x4a, 0x12, 0x2a, 0xa1, 0x72, 0xa8, 0x68, 0x7e,
+ 0xe5, 0x32, 0xc1, 0x94, 0x27, 0x69, 0x86, 0x55,
+ 0x1c, 0x4e, 0xf1, 0x25, 0xcc, 0xc0, 0x88, 0xc5,
+ 0x39, 0x86, 0x52, 0x72, 0xa6, 0xf2, 0x53, 0x5b,
+ 0xaf, 0xa3, 0xda, 0x21, 0x23, 0xce, 0x00, 0xa0,
+ 0x1f, 0xa0, 0x32, 0x1a, 0xf2, 0xe2, 0xda, 0x20,
+ 0x84, 0xba, 0x64, 0xc8, 0x84, 0xa2, 0x05, 0xd6,
+ 0xd2, 0x2f, 0xa4, 0xe5, 0x68, 0xe2, 0x2d, 0x4c,
+ 0xa5, 0x78, 0x84, 0x27, 0xca, 0xa5, 0x39, 0xc0,
+ 0x1b, 0xe0, 0xf3, 0x34, 0xf9, 0xdf, 0x32, 0xad,
+ 0xff, 0xae, 0xc2, 0x79, 0xb7, 0xfd, 0xff, 0x3f,
+ 0x9f, 0x01, 0xda, 0xd1, 0x2d, 0xff, 0xfa, 0xd5,
+ 0x2d, 0xa9, 0xcd, 0x89, 0x20, 0x4e, 0x4e, 0x13,
+ 0xbb, 0x46, 0xbe, 0xd1, 0xc3, 0xef, 0xea, 0x0f,
+ 0xce, 0x3b, 0x2c, 0xfd, 0x85, 0x6f, 0x1d, 0x89,
+ 0xbb, 0x09, 0xb6, 0x4b, 0x7b, 0xe7, 0xf9, 0x7d,
+ 0x71, 0x5d, 0xdf, 0x9c, 0x8c, 0xc6, 0x83, 0x86,
+ 0x72, 0x87, 0x07, 0x0d, 0x6b, 0x96, 0x59
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_extrusion.cpp b/src/mbgl/shaders/fill_extrusion.cpp
index 5bb2b9cd07..cff544acc1 100644
--- a/src/mbgl/shaders/fill_extrusion.cpp
+++ b/src/mbgl/shaders/fill_extrusion.cpp
@@ -1,164 +1,179 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/fill_extrusion.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* fill_extrusion::name = "fill_extrusion";
-const char* fill_extrusion::vertexSource = R"MBGL_SHADER(
-uniform mat4 u_matrix;
-uniform vec3 u_lightcolor;
-uniform lowp vec3 u_lightpos;
-uniform lowp float u_lightintensity;
-
-attribute vec2 a_pos;
-attribute vec4 a_normal_ed;
-
-varying vec4 v_color;
-
-
-#ifndef HAS_UNIFORM_u_base
-uniform lowp float a_base_t;
-attribute lowp vec2 a_base;
-varying lowp float base;
-#else
-uniform lowp float u_base;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_height
-uniform lowp float a_height_t;
-attribute lowp vec2 a_height;
-varying lowp float height;
-#else
-uniform lowp float u_height;
-#endif
-
-
-
-#ifndef HAS_UNIFORM_u_color
-uniform lowp float a_color_t;
-attribute highp vec4 a_color;
-varying highp vec4 color;
-#else
-uniform highp vec4 u_color;
-#endif
-
-
-void main() {
-
-#ifndef HAS_UNIFORM_u_base
- base = unpack_mix_vec2(a_base, a_base_t);
-#else
- lowp float base = u_base;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_height
- height = unpack_mix_vec2(a_height, a_height_t);
-#else
- lowp float height = u_height;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_color
- color = unpack_mix_vec4(a_color, a_color_t);
-#else
- highp vec4 color = u_color;
-#endif
-
-
- vec3 normal = a_normal_ed.xyz;
-
- base = max(0.0, base);
- height = max(0.0, height);
-
- float t = mod(normal.x, 2.0);
-
- gl_Position = u_matrix * vec4(a_pos, t > 0.0 ? height : base, 1);
-
- // Relative luminance (how dark/bright is the surface color?)
- float colorvalue = color.r * 0.2126 + color.g * 0.7152 + color.b * 0.0722;
-
- v_color = vec4(0.0, 0.0, 0.0, 1.0);
-
- // Add slight ambient lighting so no extrusions are totally black
- vec4 ambientlight = vec4(0.03, 0.03, 0.03, 1.0);
- color += ambientlight;
-
- // Calculate cos(theta), where theta is the angle between surface normal and diffuse light ray
- float directional = clamp(dot(normal / 16384.0, u_lightpos), 0.0, 1.0);
-
- // Adjust directional so that
- // the range of values for highlight/shading is narrower
- // with lower light intensity
- // and with lighter/brighter surface colors
- directional = mix((1.0 - u_lightintensity), max((1.0 - colorvalue + u_lightintensity), 1.0), directional);
-
- // Add gradient along z axis of side surfaces
- if (normal.y != 0.0) {
- directional *= clamp((t + base) * pow(height / 150.0, 0.5), mix(0.7, 0.98, 1.0 - u_lightintensity), 1.0);
- }
-
- // Assign final color based on surface + ambient light color, diffuse light directional, and light color
- // with lower bounds adjusted to hue of light
- // so that shading is tinted with the complementary (opposite) color to the light color
- v_color.r += clamp(color.r * directional * u_lightcolor.r, mix(0.0, 0.3, 1.0 - u_lightcolor.r), 1.0);
- v_color.g += clamp(color.g * directional * u_lightcolor.g, mix(0.0, 0.3, 1.0 - u_lightcolor.g), 1.0);
- v_color.b += clamp(color.b * directional * u_lightcolor.b, mix(0.0, 0.3, 1.0 - u_lightcolor.b), 1.0);
-}
-
-)MBGL_SHADER";
-const char* fill_extrusion::fragmentSource = R"MBGL_SHADER(
-varying vec4 v_color;
-
-#ifndef HAS_UNIFORM_u_base
-varying lowp float base;
-#else
-uniform lowp float u_base;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_height
-varying lowp float height;
-#else
-uniform lowp float u_height;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_color
-varying highp vec4 color;
-#else
-uniform highp vec4 u_color;
-#endif
-
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_base
- lowp float base = u_base;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_height
- lowp float height = u_height;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_color
- highp vec4 color = u_color;
-#endif
-
-
- gl_FragColor = v_color;
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* fill_extrusion::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x8d, 0x56, 0xdb, 0x8e, 0xdb, 0x36,
+ 0x10, 0x7d, 0xf7, 0x57, 0x4c, 0x91, 0x17, 0x39,
+ 0xab, 0xfa, 0xb6, 0xde, 0x6c, 0xda, 0xc5, 0x26,
+ 0x08, 0x0a, 0x14, 0xed, 0x43, 0xda, 0x22, 0x45,
+ 0x9f, 0x05, 0xca, 0xa2, 0x24, 0x26, 0x14, 0x29,
+ 0x50, 0x94, 0x2f, 0x29, 0xf2, 0xef, 0x19, 0xde,
+ 0x74, 0x5b, 0xd9, 0xc8, 0x3e, 0x78, 0x2d, 0xce,
+ 0x70, 0xe6, 0xcc, 0x39, 0x33, 0x23, 0xb7, 0x82,
+ 0xe5, 0x52, 0x55, 0x50, 0x11, 0xbd, 0x87, 0x36,
+ 0xc1, 0x7f, 0x8a, 0x9d, 0x9f, 0x16, 0xad, 0x3f,
+ 0x3e, 0xd2, 0xc3, 0x3d, 0x1e, 0x73, 0x56, 0x94,
+ 0xfa, 0x20, 0xb9, 0x54, 0xbd, 0x89, 0xcb, 0x53,
+ 0x3d, 0xb2, 0xd7, 0xb2, 0x99, 0x58, 0x73, 0x2e,
+ 0x89, 0x0e, 0x66, 0x26, 0x34, 0x15, 0x0d, 0xd3,
+ 0x97, 0xa7, 0xc5, 0x82, 0x68, 0x4c, 0x93, 0xb6,
+ 0x9a, 0x9a, 0x00, 0x3b, 0x20, 0x89, 0xbd, 0x3b,
+ 0x3a, 0xdd, 0xe3, 0xa9, 0xc0, 0x48, 0x84, 0x27,
+ 0x34, 0xc3, 0x2b, 0x47, 0xa2, 0x2e, 0x4c, 0x14,
+ 0xce, 0x74, 0x4c, 0x3c, 0x98, 0xc5, 0xe2, 0x15,
+ 0xcb, 0x45, 0x46, 0x73, 0xf8, 0xe3, 0xc3, 0xbf,
+ 0xc9, 0x7f, 0x7f, 0xfd, 0xf9, 0xfb, 0xdf, 0x9f,
+ 0x3e, 0x26, 0x6d, 0x92, 0x92, 0x86, 0xce, 0x61,
+ 0x21, 0xd6, 0x92, 0xe8, 0x61, 0xb2, 0x50, 0xc8,
+ 0xce, 0x5b, 0x9f, 0xba, 0x5c, 0x83, 0x8b, 0xce,
+ 0xf0, 0x8a, 0xf2, 0xf9, 0xb8, 0x6d, 0x12, 0x1c,
+ 0x44, 0xc6, 0xf2, 0xab, 0xb0, 0x4a, 0x6a, 0x98,
+ 0x98, 0x07, 0xe6, 0x6c, 0xd7, 0xa1, 0x39, 0xfb,
+ 0x2c, 0xb8, 0x60, 0xba, 0x01, 0xaf, 0x77, 0xf1,
+ 0x00, 0xaf, 0x20, 0xb4, 0xbc, 0xce, 0x03, 0xb4,
+ 0xa6, 0x31, 0xbe, 0x12, 0x83, 0xd6, 0x41, 0x2d,
+ 0x2f, 0x49, 0xc0, 0x37, 0xb0, 0x79, 0xcb, 0x18,
+ 0xde, 0xc0, 0xde, 0x26, 0x9d, 0x87, 0x47, 0x77,
+ 0x94, 0x2c, 0xc3, 0x9e, 0x64, 0x22, 0x5a, 0xc2,
+ 0xff, 0x0b, 0xc0, 0xbf, 0x5b, 0x42, 0x1b, 0xbb,
+ 0xf9, 0x02, 0xcf, 0xd0, 0x8a, 0x9a, 0x1c, 0xbe,
+ 0x24, 0x15, 0x3b, 0x27, 0x86, 0xb7, 0xc8, 0x49,
+ 0x1a, 0x77, 0xc2, 0x2f, 0x03, 0x0c, 0x73, 0x67,
+ 0xa2, 0xaf, 0xb9, 0x3e, 0xd1, 0xf1, 0x46, 0x66,
+ 0xaf, 0xa5, 0xf1, 0x70, 0x5f, 0x67, 0xb3, 0x3b,
+ 0x53, 0x3c, 0xd0, 0xf7, 0x1a, 0x82, 0x3e, 0xc8,
+ 0x0b, 0xb1, 0x6e, 0xa0, 0x70, 0x7a, 0x19, 0x07,
+ 0xfb, 0xed, 0x05, 0x86, 0x7d, 0xe4, 0x85, 0x89,
+ 0x7b, 0x05, 0x47, 0x08, 0xa6, 0x32, 0x59, 0x00,
+ 0x53, 0x39, 0x8c, 0xa3, 0x1d, 0x75, 0x37, 0x91,
+ 0xe8, 0x33, 0x18, 0xce, 0xd5, 0xf9, 0xf2, 0xf5,
+ 0x69, 0x31, 0x14, 0xa1, 0x22, 0xe7, 0x68, 0xb3,
+ 0xda, 0xc4, 0xf6, 0x19, 0xb3, 0x8d, 0x38, 0xea,
+ 0x8c, 0xee, 0x64, 0xe9, 0xaf, 0x3a, 0x12, 0xac,
+ 0x83, 0xcc, 0x22, 0x17, 0x7c, 0x75, 0x8e, 0x61,
+ 0xb7, 0xda, 0x04, 0x97, 0x82, 0x27, 0xff, 0x48,
+ 0xdc, 0x20, 0x4c, 0x0a, 0x8b, 0xd2, 0x2d, 0x2b,
+ 0x78, 0x0d, 0xbe, 0x4e, 0x5c, 0x22, 0x31, 0x46,
+ 0x78, 0x07, 0x18, 0x1e, 0xde, 0x87, 0x8c, 0xbf,
+ 0x82, 0xeb, 0x80, 0x6d, 0x08, 0xb3, 0x5e, 0xc3,
+ 0x27, 0xca, 0x89, 0x66, 0x47, 0x1c, 0xb0, 0xb6,
+ 0x62, 0x82, 0x88, 0x03, 0x85, 0xa8, 0x94, 0x27,
+ 0xc8, 0x88, 0xfa, 0xb2, 0x4e, 0x95, 0xbd, 0xc7,
+ 0x1a, 0xd0, 0x25, 0x85, 0xa6, 0x55, 0x39, 0x41,
+ 0xbb, 0xa5, 0xe4, 0xfd, 0x72, 0x80, 0xd5, 0x9e,
+ 0x1c, 0x09, 0x6f, 0x4d, 0xc9, 0xf6, 0x61, 0xa5,
+ 0x10, 0xcc, 0x66, 0xb5, 0xdb, 0xee, 0xde, 0xc0,
+ 0x9d, 0x3f, 0x2a, 0xec, 0xd1, 0xe3, 0xf6, 0x61,
+ 0xd7, 0x1d, 0xa5, 0xf6, 0x68, 0xf3, 0xb8, 0xdb,
+ 0x79, 0x44, 0x7e, 0x9d, 0x61, 0x18, 0x5b, 0x89,
+ 0x65, 0xa7, 0xff, 0xd8, 0xf6, 0x0c, 0x20, 0xf4,
+ 0x0f, 0x59, 0x06, 0x8d, 0x5d, 0xa8, 0x40, 0xaa,
+ 0x94, 0x51, 0xa1, 0xc1, 0xaf, 0xd7, 0x02, 0x1a,
+ 0x89, 0x02, 0x01, 0x3d, 0x6b, 0xd5, 0x36, 0x48,
+ 0x52, 0x03, 0x44, 0x51, 0xd0, 0x52, 0x13, 0xce,
+ 0x2f, 0x90, 0x72, 0x6c, 0x8b, 0xa0, 0xe4, 0x3e,
+ 0x5c, 0xe6, 0x5e, 0x95, 0x90, 0xf8, 0xde, 0x26,
+ 0xed, 0x3e, 0x5d, 0xee, 0xbe, 0xbd, 0xee, 0x9e,
+ 0x47, 0x17, 0x7b, 0x58, 0xbf, 0x11, 0x7e, 0x68,
+ 0x91, 0x54, 0x43, 0x54, 0x13, 0x21, 0x71, 0x9a,
+ 0x2c, 0x63, 0x38, 0x95, 0xd4, 0x20, 0x30, 0x4f,
+ 0x81, 0x4f, 0x22, 0x0a, 0x4e, 0x21, 0xa5, 0xfa,
+ 0x44, 0xa9, 0xe8, 0xd8, 0xf5, 0x7d, 0x45, 0x44,
+ 0x06, 0xd8, 0x71, 0x79, 0x8b, 0x6d, 0xe4, 0x90,
+ 0x29, 0x72, 0x19, 0x50, 0x9e, 0x31, 0x45, 0x0f,
+ 0x46, 0x7f, 0xdb, 0x83, 0x07, 0x4e, 0xaa, 0x3a,
+ 0xca, 0xa4, 0xf6, 0xed, 0x02, 0x6b, 0xd8, 0xbe,
+ 0xb9, 0x7f, 0xbb, 0x37, 0xa4, 0xf5, 0xef, 0xa4,
+ 0xe5, 0x15, 0x1a, 0x3f, 0xb7, 0xcd, 0x38, 0x20,
+ 0xb2, 0xa7, 0x4b, 0xa2, 0x83, 0x87, 0x01, 0xab,
+ 0x10, 0x2d, 0x05, 0x99, 0x83, 0x95, 0xb9, 0x01,
+ 0x5c, 0x5c, 0x76, 0x60, 0x6c, 0xec, 0x75, 0x53,
+ 0x92, 0xcc, 0xd0, 0x8e, 0x95, 0x09, 0xa2, 0x94,
+ 0x3c, 0x51, 0x15, 0x2e, 0x9f, 0x98, 0x2e, 0xcd,
+ 0x70, 0x53, 0xe5, 0xeb, 0xe8, 0xde, 0x7e, 0xc1,
+ 0xc3, 0x94, 0xea, 0xbc, 0x8c, 0x9d, 0x2a, 0xdf,
+ 0x76, 0x78, 0x61, 0xd4, 0x71, 0x8d, 0xf5, 0x1f,
+ 0xd7, 0x8d, 0xa3, 0x1d, 0x45, 0x58, 0x0e, 0xfc,
+ 0xfc, 0xe2, 0xdd, 0x8a, 0xc5, 0x9a, 0xf9, 0xf2,
+ 0xd6, 0x41, 0x87, 0xde, 0xcd, 0xb9, 0x1a, 0x4a,
+ 0xe2, 0x61, 0xf0, 0x49, 0x9f, 0x15, 0x0a, 0x0b,
+ 0x34, 0x1d, 0x46, 0xb8, 0xc4, 0x3a, 0xbf, 0x02,
+ 0x39, 0x63, 0xad, 0x48, 0x47, 0xc3, 0xb2, 0x6e,
+ 0x32, 0x1c, 0x42, 0x96, 0x43, 0x18, 0xda, 0x0b,
+ 0xfc, 0xf4, 0x6c, 0x28, 0x0f, 0x9b, 0x7b, 0x5a,
+ 0xc0, 0xeb, 0xa0, 0x5c, 0xa4, 0x11, 0x96, 0x5d,
+ 0x11, 0x38, 0x10, 0xb5, 0x3c, 0x45, 0x7e, 0x62,
+ 0x51, 0xc6, 0x07, 0xdf, 0xfe, 0x0f, 0xa6, 0x20,
+ 0x66, 0x16, 0xc6, 0xa3, 0x79, 0xfc, 0xe5, 0xad,
+ 0x05, 0x3d, 0x5f, 0x78, 0xdf, 0xab, 0xdf, 0xfa,
+ 0x2a, 0x9a, 0x86, 0x15, 0x02, 0x72, 0x66, 0x12,
+ 0xbb, 0x16, 0x36, 0x09, 0x33, 0x90, 0x7d, 0xef,
+ 0xdd, 0x8d, 0x07, 0x09, 0xfc, 0xba, 0x1c, 0xf7,
+ 0xe1, 0xa0, 0x80, 0xd8, 0x6a, 0x37, 0xf0, 0x9d,
+ 0x11, 0x3d, 0x95, 0xad, 0xc8, 0x70, 0xfe, 0x6c,
+ 0x97, 0x61, 0x3a, 0x2d, 0xa1, 0x6c, 0x6d, 0x27,
+ 0xf1, 0xee, 0xad, 0x81, 0x37, 0x7c, 0xcb, 0xc1,
+ 0xa0, 0x93, 0x6c, 0x49, 0xbe, 0x35, 0x4c, 0x0b,
+ 0x1e, 0x64, 0x55, 0x73, 0x5a, 0x21, 0x3c, 0x7c,
+ 0xaf, 0x42, 0x24, 0xeb, 0xda, 0xac, 0x40, 0xa4,
+ 0xcc, 0x55, 0xa3, 0xa5, 0xf5, 0x9a, 0xa2, 0xf1,
+ 0x1b, 0x65, 0x65, 0x27, 0xd6, 0xb1, 0xdd, 0x6f,
+ 0xa8, 0x91, 0x18, 0xa3, 0x5f, 0x77, 0x2b, 0x15,
+ 0xe8, 0xb6, 0xec, 0xdf, 0x4f, 0xd8, 0xf6, 0x3e,
+ 0x23, 0xae, 0x43, 0xa6, 0x62, 0x9a, 0xa9, 0xb8,
+ 0x9d, 0xa9, 0xf8, 0x81, 0x4c, 0xc5, 0x6c, 0xa6,
+ 0x74, 0x9a, 0x29, 0xbd, 0x9d, 0x29, 0xfd, 0x81,
+ 0x4c, 0x69, 0x97, 0xe9, 0xdb, 0xe2, 0x3b, 0xe2,
+ 0x90, 0x8c, 0xa9
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* fill_extrusion::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x7d, 0x52, 0xbb, 0x0a, 0xc2, 0x30,
+ 0x14, 0xdd, 0xf3, 0x15, 0x17, 0x5c, 0x74, 0x11,
+ 0x05, 0x37, 0x71, 0x10, 0xb5, 0xe8, 0xa0, 0x95,
+ 0xfa, 0x1a, 0x43, 0xb4, 0x49, 0x1b, 0x88, 0x89,
+ 0x54, 0x1b, 0x11, 0xf1, 0xdf, 0x6d, 0x9a, 0x50,
+ 0x35, 0x5a, 0x33, 0xde, 0xf3, 0xe2, 0x1c, 0xa2,
+ 0x49, 0x76, 0xe3, 0x32, 0x01, 0x4d, 0x0f, 0x3d,
+ 0xd0, 0xf8, 0xa0, 0x84, 0xca, 0xfa, 0x08, 0x35,
+ 0x38, 0x93, 0x31, 0x65, 0x30, 0x1d, 0xae, 0xf0,
+ 0x66, 0x31, 0x0b, 0xc2, 0x68, 0x8e, 0x73, 0xbc,
+ 0x27, 0x67, 0x8a, 0xb4, 0x53, 0x08, 0x75, 0x3d,
+ 0x01, 0x13, 0x8a, 0x5c, 0xc0, 0xdc, 0xfb, 0xa8,
+ 0x41, 0x45, 0x01, 0xe7, 0x92, 0x33, 0x95, 0x1d,
+ 0xdf, 0x61, 0x2b, 0x34, 0x04, 0x19, 0x73, 0x86,
+ 0xea, 0xdc, 0x53, 0xca, 0x93, 0xf4, 0xf2, 0xcb,
+ 0xdf, 0x22, 0x7f, 0x13, 0x5e, 0x94, 0xbf, 0x19,
+ 0x65, 0xbf, 0x2a, 0x22, 0x2d, 0x34, 0x27, 0x5b,
+ 0xdd, 0x15, 0xff, 0x4c, 0x78, 0xc3, 0x73, 0x5c,
+ 0x31, 0x5c, 0x80, 0x56, 0x3c, 0x86, 0x23, 0xe1,
+ 0xb2, 0xd9, 0x82, 0x3b, 0x82, 0xe2, 0x99, 0xcc,
+ 0x9a, 0xd1, 0x0c, 0xec, 0x0d, 0x06, 0x83, 0xaf,
+ 0x61, 0xea, 0x4d, 0xdc, 0x36, 0x9e, 0x8d, 0xbd,
+ 0x96, 0x46, 0x7e, 0xff, 0x7a, 0x2b, 0x3b, 0x81,
+ 0xc1, 0xfd, 0xfa, 0xa5, 0x91, 0x5f, 0xd3, 0x10,
+ 0x13, 0x81, 0x83, 0x8c, 0x24, 0x23, 0x47, 0xfa,
+ 0xf8, 0x26, 0x26, 0x20, 0xdc, 0x4e, 0xa2, 0x71,
+ 0x34, 0xdc, 0xe1, 0xd9, 0x62, 0xb5, 0x9c, 0x8c,
+ 0xd6, 0x61, 0xf4, 0x53, 0x56, 0x04, 0x35, 0xbb,
+ 0xed, 0x4e, 0xab, 0x72, 0x7f, 0xa0, 0x27, 0xc6,
+ 0x6e, 0xcd, 0x58
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_extrusion_pattern.cpp b/src/mbgl/shaders/fill_extrusion_pattern.cpp
index 466d0e04fe..d2e3e6d51a 100644
--- a/src/mbgl/shaders/fill_extrusion_pattern.cpp
+++ b/src/mbgl/shaders/fill_extrusion_pattern.cpp
@@ -1,158 +1,169 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/fill_extrusion_pattern.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* fill_extrusion_pattern::name = "fill_extrusion_pattern";
-const char* fill_extrusion_pattern::vertexSource = R"MBGL_SHADER(
-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;
-uniform float u_height_factor;
-
-uniform vec3 u_lightcolor;
-uniform lowp vec3 u_lightpos;
-uniform lowp float u_lightintensity;
-
-attribute vec2 a_pos;
-attribute vec4 a_normal_ed;
-
-varying vec2 v_pos_a;
-varying vec2 v_pos_b;
-varying vec4 v_lighting;
-varying float v_directional;
-
-
-#ifndef HAS_UNIFORM_u_base
-uniform lowp float a_base_t;
-attribute lowp vec2 a_base;
-varying lowp float base;
-#else
-uniform lowp float u_base;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_height
-uniform lowp float a_height_t;
-attribute lowp vec2 a_height;
-varying lowp float height;
-#else
-uniform lowp float u_height;
-#endif
-
-
-void main() {
-
-#ifndef HAS_UNIFORM_u_base
- base = unpack_mix_vec2(a_base, a_base_t);
-#else
- lowp float base = u_base;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_height
- height = unpack_mix_vec2(a_height, a_height_t);
-#else
- lowp float height = u_height;
-#endif
-
-
- vec3 normal = a_normal_ed.xyz;
- float edgedistance = a_normal_ed.w;
-
- base = max(0.0, base);
- height = max(0.0, height);
-
- float t = mod(normal.x, 2.0);
- float z = t > 0.0 ? height : base;
-
- gl_Position = u_matrix * vec4(a_pos, z, 1);
-
- vec2 pos = normal.x == 1.0 && normal.y == 0.0 && normal.z == 16384.0
- ? a_pos // extrusion top
- : vec2(edgedistance, z * u_height_factor); // extrusion side
-
- 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, 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, pos);
-
- v_lighting = vec4(0.0, 0.0, 0.0, 1.0);
- float directional = clamp(dot(normal / 16383.0, u_lightpos), 0.0, 1.0);
- directional = mix((1.0 - u_lightintensity), max((0.5 + u_lightintensity), 1.0), directional);
-
- if (normal.y != 0.0) {
- directional *= clamp((t + base) * pow(height / 150.0, 0.5), mix(0.7, 0.98, 1.0 - u_lightintensity), 1.0);
- }
-
- v_lighting.rgb += clamp(directional * u_lightcolor, mix(vec3(0.0), vec3(0.3), 1.0 - u_lightcolor), vec3(1.0));
-}
-
-)MBGL_SHADER";
-const char* fill_extrusion_pattern::fragmentSource = R"MBGL_SHADER(
-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 sampler2D u_image;
-
-varying vec2 v_pos_a;
-varying vec2 v_pos_b;
-varying vec4 v_lighting;
-
-
-#ifndef HAS_UNIFORM_u_base
-varying lowp float base;
-#else
-uniform lowp float u_base;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_height
-varying lowp float height;
-#else
-uniform lowp float u_height;
-#endif
-
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_base
- lowp float base = u_base;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_height
- lowp float height = u_height;
-#endif
-
-
- 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);
-
- vec4 mixedColor = mix(color1, color2, u_mix);
-
- gl_FragColor = mixedColor * v_lighting;
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* fill_extrusion_pattern::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0xad, 0x55, 0xc9, 0x6e, 0xdb, 0x30,
+ 0x10, 0xbd, 0xfb, 0x2b, 0x58, 0x04, 0x08, 0xa8,
+ 0x44, 0x75, 0x9c, 0xd8, 0x69, 0xd3, 0x18, 0x69,
+ 0xd0, 0x4b, 0xd1, 0x1e, 0xba, 0xa0, 0x45, 0xcf,
+ 0x04, 0x25, 0x51, 0x0a, 0x51, 0x59, 0x14, 0x24,
+ 0xca, 0x91, 0x5d, 0xe4, 0xdf, 0x3b, 0xdc, 0x2c,
+ 0x6a, 0xb1, 0x7b, 0xa9, 0x0f, 0xb6, 0x3c, 0x6f,
+ 0x96, 0xc7, 0xc7, 0x99, 0x51, 0x53, 0xf0, 0x54,
+ 0x54, 0x1b, 0xb4, 0xa1, 0x72, 0x85, 0x1a, 0x02,
+ 0x3f, 0x15, 0x6f, 0xd7, 0xb3, 0xc6, 0x9a, 0xb7,
+ 0x2c, 0xbe, 0x01, 0x73, 0x49, 0xa5, 0x64, 0x55,
+ 0x41, 0x6a, 0xbe, 0x67, 0x84, 0x9e, 0x86, 0xa3,
+ 0x31, 0xcc, 0x5b, 0x96, 0x93, 0x58, 0x88, 0x2a,
+ 0x21, 0x4d, 0x59, 0xb2, 0xea, 0xa4, 0x47, 0x2e,
+ 0x9e, 0x7d, 0x8f, 0x34, 0x17, 0x54, 0x82, 0x4b,
+ 0x1d, 0xd3, 0xbc, 0x57, 0xbb, 0x0f, 0x44, 0x63,
+ 0x40, 0x72, 0xb0, 0x83, 0x51, 0xd6, 0x44, 0x0a,
+ 0x53, 0xa2, 0x1e, 0x7b, 0x3d, 0x31, 0x9e, 0x3d,
+ 0x49, 0x92, 0xd2, 0x58, 0x0a, 0x28, 0xeb, 0x33,
+ 0x5b, 0x02, 0x9c, 0x2b, 0x34, 0x16, 0xb9, 0xf0,
+ 0x28, 0x01, 0xc3, 0xb2, 0x87, 0x97, 0xa2, 0x1e,
+ 0xa0, 0x2e, 0xbb, 0x86, 0x79, 0x21, 0x59, 0x51,
+ 0x73, 0xb9, 0x83, 0xf4, 0xa0, 0x54, 0xc5, 0xa3,
+ 0x46, 0x32, 0x73, 0x74, 0x4a, 0x74, 0x6c, 0xcf,
+ 0xba, 0x02, 0x6b, 0x01, 0x99, 0x68, 0x4e, 0x58,
+ 0x02, 0x21, 0x5b, 0x5a, 0xed, 0x78, 0x91, 0x99,
+ 0x80, 0xad, 0x0a, 0x50, 0x32, 0x4c, 0x58, 0xa3,
+ 0x9e, 0x75, 0x05, 0x56, 0x5b, 0x3e, 0xeb, 0x00,
+ 0x43, 0x6c, 0x4b, 0x12, 0x5e, 0xb1, 0x58, 0x72,
+ 0x51, 0xd0, 0x1c, 0x4a, 0xcc, 0xce, 0x78, 0x5a,
+ 0x24, 0x2c, 0x45, 0x9f, 0x3e, 0xfc, 0x24, 0xbf,
+ 0xbe, 0x7e, 0xfe, 0xf8, 0xed, 0xc7, 0x17, 0xd2,
+ 0x90, 0x88, 0xd6, 0x6c, 0xea, 0x5c, 0x54, 0x23,
+ 0x44, 0xfa, 0xc4, 0x9d, 0x28, 0x37, 0x16, 0xed,
+ 0x4a, 0x7a, 0x81, 0x06, 0x38, 0x83, 0x8b, 0x60,
+ 0xd3, 0x7a, 0x39, 0x87, 0x22, 0xe1, 0xe9, 0x51,
+ 0x5a, 0xe6, 0xca, 0xa6, 0x89, 0xd9, 0xeb, 0x3c,
+ 0x4a, 0xcd, 0xe0, 0x93, 0xe4, 0x1c, 0x74, 0x82,
+ 0x5e, 0xe7, 0x62, 0x09, 0x6e, 0x05, 0x4f, 0x60,
+ 0x76, 0x78, 0x81, 0x03, 0xf4, 0x67, 0x86, 0xe0,
+ 0x73, 0x4a, 0x4a, 0x85, 0xab, 0x07, 0xf4, 0x80,
+ 0x9a, 0xa2, 0xa4, 0xf1, 0x6f, 0xb2, 0xe1, 0x2d,
+ 0x51, 0xcc, 0xb0, 0x11, 0x2d, 0x3c, 0x48, 0x1b,
+ 0x38, 0x1e, 0x2a, 0x66, 0xa0, 0xa0, 0x0a, 0x1f,
+ 0x28, 0x75, 0xa2, 0xb2, 0x55, 0x4b, 0x79, 0x98,
+ 0xc7, 0xc9, 0xea, 0x06, 0x0a, 0x3d, 0x05, 0x8f,
+ 0x31, 0xe8, 0x92, 0x8c, 0xe5, 0x50, 0xae, 0x7a,
+ 0x30, 0x4c, 0xff, 0x82, 0x93, 0xd7, 0xca, 0xf3,
+ 0x76, 0xb7, 0x5f, 0x6b, 0x17, 0x93, 0x88, 0x25,
+ 0x19, 0x4b, 0x78, 0x2d, 0x69, 0x11, 0xb3, 0x81,
+ 0xe7, 0xf3, 0x7a, 0xe6, 0x8b, 0xb5, 0xa1, 0x2d,
+ 0x5e, 0xcc, 0x17, 0xa1, 0xfe, 0x1f, 0xac, 0xfb,
+ 0x67, 0x39, 0x80, 0xc6, 0x12, 0xd8, 0x50, 0x53,
+ 0x43, 0x3b, 0x88, 0x04, 0x9b, 0xd4, 0xf3, 0x36,
+ 0x44, 0x37, 0xf3, 0x45, 0xe0, 0xb3, 0xd8, 0x83,
+ 0x87, 0x44, 0xef, 0x11, 0xa4, 0x40, 0x8f, 0x2e,
+ 0xeb, 0xbd, 0xed, 0x54, 0xed, 0x97, 0xe5, 0xe4,
+ 0xbb, 0x80, 0xf1, 0x85, 0x61, 0xd1, 0xa7, 0x36,
+ 0x3b, 0x12, 0x5d, 0xe8, 0x21, 0xc3, 0x7a, 0x82,
+ 0x43, 0xb4, 0x0f, 0xd1, 0xb5, 0x2b, 0xad, 0x5b,
+ 0x0d, 0xac, 0xe0, 0xed, 0xea, 0xa2, 0x87, 0x07,
+ 0x74, 0x0d, 0x15, 0xce, 0xcf, 0x9d, 0x69, 0xa7,
+ 0x4c, 0x8b, 0x9e, 0x69, 0xaf, 0xbd, 0xde, 0x2c,
+ 0xef, 0x56, 0xf3, 0x85, 0x4e, 0xa4, 0x3e, 0x8f,
+ 0x66, 0x47, 0xa0, 0xab, 0x2b, 0xc4, 0x5a, 0x59,
+ 0x35, 0xb5, 0xa2, 0x21, 0x45, 0x79, 0x70, 0xb8,
+ 0xd7, 0xf5, 0xb0, 0xaf, 0x26, 0xd0, 0x01, 0x7a,
+ 0x83, 0xdd, 0x16, 0xac, 0xfb, 0x39, 0x6a, 0x9e,
+ 0x30, 0xcb, 0xd7, 0xec, 0x14, 0xa0, 0x9b, 0x31,
+ 0x79, 0x58, 0xe6, 0x60, 0xc3, 0x13, 0xbb, 0x3b,
+ 0x9c, 0x5a, 0xd7, 0x61, 0xb7, 0xa0, 0x75, 0xe1,
+ 0xfe, 0xfb, 0x22, 0x3c, 0xb2, 0x8c, 0x43, 0x25,
+ 0x92, 0xbd, 0x0c, 0xbb, 0xc1, 0xfe, 0x0b, 0x87,
+ 0x68, 0xcc, 0x21, 0xfa, 0x17, 0x07, 0x4b, 0xc2,
+ 0x2d, 0x4c, 0xe0, 0xa1, 0x6f, 0x57, 0x37, 0x56,
+ 0xf7, 0x75, 0x3d, 0x68, 0x1e, 0x6f, 0x8b, 0x42,
+ 0x44, 0x9c, 0xd3, 0x4d, 0x89, 0x13, 0x21, 0x6d,
+ 0xbb, 0xa1, 0x2b, 0x7d, 0x9b, 0x4b, 0x15, 0xd9,
+ 0xbd, 0x29, 0x82, 0x51, 0xae, 0x7e, 0x16, 0x18,
+ 0x4a, 0x8c, 0x55, 0xaf, 0xbc, 0x1e, 0xbd, 0x3f,
+ 0x20, 0x54, 0x75, 0x3b, 0xb0, 0xba, 0x45, 0x97,
+ 0x53, 0xa8, 0xca, 0x19, 0xfa, 0xf9, 0xdc, 0xc9,
+ 0x78, 0x8a, 0xf0, 0xa1, 0xf1, 0x5e, 0xe9, 0xc6,
+ 0x73, 0x0b, 0x6b, 0xc8, 0xe0, 0xc2, 0x1d, 0x04,
+ 0x4b, 0x28, 0xa2, 0x27, 0x0e, 0xf4, 0x2c, 0xc5,
+ 0x33, 0xb6, 0xc3, 0x01, 0xa7, 0xba, 0xb5, 0x92,
+ 0xdc, 0x2a, 0x46, 0x5c, 0xcd, 0xdf, 0x5b, 0xf5,
+ 0xf7, 0xdd, 0x9d, 0xa6, 0x30, 0xcd, 0xbc, 0x3b,
+ 0xef, 0xcb, 0x50, 0xed, 0x79, 0x95, 0x45, 0xe8,
+ 0xf2, 0x20, 0xa0, 0x4f, 0xa6, 0xf7, 0x0a, 0x36,
+ 0xc5, 0xd4, 0x82, 0x51, 0x17, 0x03, 0x39, 0xed,
+ 0xe3, 0x32, 0x18, 0xd4, 0xd5, 0xde, 0x0e, 0x57,
+ 0x85, 0xa1, 0xf2, 0xcb, 0xec, 0x2f, 0xc0, 0xf5,
+ 0xee, 0x94
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* fill_extrusion_pattern::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x7d, 0x93, 0xcb, 0x6e, 0x83, 0x30,
+ 0x10, 0x45, 0xf7, 0x7c, 0x85, 0xa5, 0x6c, 0x48,
+ 0x85, 0xda, 0x06, 0x65, 0x87, 0xba, 0x88, 0xf2,
+ 0x50, 0xb3, 0x68, 0x52, 0x91, 0x3e, 0x96, 0x96,
+ 0x1d, 0x0c, 0xb1, 0x64, 0x30, 0x32, 0x8f, 0xa6,
+ 0xad, 0xfa, 0xef, 0xb5, 0x63, 0x27, 0x84, 0x60,
+ 0x60, 0xc7, 0xdc, 0x3b, 0x77, 0x8e, 0xf1, 0x50,
+ 0x65, 0x34, 0xe6, 0x22, 0x05, 0x35, 0xd9, 0xfb,
+ 0xa0, 0x82, 0x39, 0x2a, 0x4b, 0x22, 0x32, 0x58,
+ 0x32, 0x88, 0x02, 0xa7, 0xb2, 0x8b, 0x58, 0x0c,
+ 0x88, 0xb2, 0x13, 0x0f, 0x75, 0x76, 0xc5, 0x92,
+ 0x1c, 0x0b, 0xfa, 0x43, 0x9a, 0x7a, 0xcc, 0x38,
+ 0x2a, 0xa5, 0x90, 0xd2, 0x63, 0xe0, 0x5c, 0xaa,
+ 0x05, 0x4a, 0x73, 0x46, 0x84, 0xbf, 0x90, 0x0a,
+ 0x4d, 0x51, 0x22, 0x1b, 0x9c, 0x1a, 0x89, 0x6f,
+ 0x9a, 0x25, 0x3a, 0xa9, 0x86, 0x39, 0x2f, 0x14,
+ 0x99, 0xa5, 0x8a, 0x5b, 0xd5, 0xa9, 0xac, 0x32,
+ 0x9a, 0x1c, 0x4a, 0xf9, 0x2e, 0x53, 0x9c, 0x11,
+ 0x8d, 0xb3, 0x88, 0xc4, 0xe0, 0x79, 0xb6, 0x83,
+ 0xef, 0x9b, 0xf5, 0x6a, 0x1b, 0xbe, 0xc0, 0x0a,
+ 0x62, 0x54, 0x90, 0x4b, 0x17, 0xe3, 0x5f, 0xb9,
+ 0x01, 0x53, 0xf5, 0xc0, 0x19, 0x11, 0x26, 0xe5,
+ 0x33, 0xdc, 0x95, 0xac, 0x1b, 0x95, 0x21, 0x8b,
+ 0x68, 0xdc, 0x9b, 0x7e, 0x20, 0x0a, 0xc0, 0x96,
+ 0xaf, 0x95, 0xc1, 0x09, 0x8d, 0xc5, 0xcc, 0xa8,
+ 0x39, 0x8d, 0x40, 0x8a, 0x68, 0xe6, 0x8e, 0xc1,
+ 0xaf, 0x03, 0xe4, 0xa3, 0xc6, 0xf6, 0x9c, 0x49,
+ 0xc9, 0x37, 0xe7, 0x01, 0x4f, 0x1d, 0xee, 0xfe,
+ 0x10, 0x83, 0x7e, 0x13, 0xa3, 0xab, 0xa7, 0xa0,
+ 0x0e, 0x9e, 0xb2, 0x9e, 0x6e, 0xe3, 0x74, 0x71,
+ 0x7b, 0xce, 0x45, 0x24, 0x8d, 0x29, 0x8f, 0x5c,
+ 0x73, 0x69, 0x1e, 0x98, 0xdc, 0x3f, 0x8e, 0x83,
+ 0xc6, 0x28, 0xab, 0xca, 0x41, 0x8f, 0x6e, 0x7b,
+ 0x29, 0xc1, 0x43, 0xb3, 0x31, 0xde, 0xcd, 0x4e,
+ 0xb6, 0xb5, 0x66, 0x54, 0x93, 0x3b, 0x05, 0x7b,
+ 0xce, 0xb8, 0x98, 0xc8, 0x68, 0xe9, 0x2b, 0x2b,
+ 0x41, 0xfc, 0x85, 0x6b, 0xd6, 0xc9, 0x53, 0x33,
+ 0xa5, 0xd5, 0x06, 0x0b, 0x71, 0x0b, 0x17, 0xdb,
+ 0x70, 0x7d, 0x1b, 0x2f, 0x1e, 0xe0, 0xc5, 0x7d,
+ 0xbc, 0x10, 0x77, 0x88, 0xfd, 0x5e, 0x62, 0xff,
+ 0x0a, 0x79, 0xaa, 0x00, 0x48, 0x34, 0x57, 0x1d,
+ 0x86, 0x46, 0x9f, 0xd7, 0x33, 0x29, 0x9e, 0xfe,
+ 0xab, 0xce, 0x2d, 0x09, 0x83, 0x2b, 0x81, 0x92,
+ 0x2b, 0xff, 0xb9, 0xf9, 0xae, 0xfd, 0x87, 0x98,
+ 0x35, 0xd8, 0x7e, 0x2c, 0xc3, 0x45, 0x38, 0xfb,
+ 0x84, 0xeb, 0xcd, 0xee, 0x75, 0x39, 0x7f, 0xdb,
+ 0x86, 0xb6, 0x18, 0x05, 0xe2, 0xea, 0xef, 0x63,
+ 0x16, 0xe0, 0xcf, 0xf9, 0x07, 0xbd, 0xf2, 0x75,
+ 0x6c
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_outline.cpp b/src/mbgl/shaders/fill_outline.cpp
index 9ade598d10..367ff7580c 100644
--- a/src/mbgl/shaders/fill_outline.cpp
+++ b/src/mbgl/shaders/fill_outline.cpp
@@ -1,99 +1,104 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/fill_outline.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* fill_outline::name = "fill_outline";
-const char* fill_outline::vertexSource = R"MBGL_SHADER(
-attribute vec2 a_pos;
-
-uniform mat4 u_matrix;
-uniform vec2 u_world;
-
-varying vec2 v_pos;
-
-
-#ifndef HAS_UNIFORM_u_outline_color
-uniform lowp float a_outline_color_t;
-attribute highp vec4 a_outline_color;
-varying highp vec4 outline_color;
-#else
-uniform highp vec4 u_outline_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-uniform lowp float a_opacity_t;
-attribute lowp vec2 a_opacity;
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-void main() {
-
-#ifndef HAS_UNIFORM_u_outline_color
- outline_color = unpack_mix_vec4(a_outline_color, a_outline_color_t);
-#else
- highp vec4 outline_color = u_outline_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
- opacity = unpack_mix_vec2(a_opacity, a_opacity_t);
-#else
- lowp float opacity = u_opacity;
-#endif
-
-
- gl_Position = u_matrix * vec4(a_pos, 0, 1);
- v_pos = (gl_Position.xy / gl_Position.w + 1.0) / 2.0 * u_world;
-}
-
-)MBGL_SHADER";
-const char* fill_outline::fragmentSource = R"MBGL_SHADER(
-
-#ifndef HAS_UNIFORM_u_outline_color
-varying highp vec4 outline_color;
-#else
-uniform highp vec4 u_outline_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-varying vec2 v_pos;
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_outline_color
- highp vec4 outline_color = u_outline_color;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_opacity
- lowp float opacity = u_opacity;
-#endif
-
-
- float dist = length(v_pos - gl_FragCoord.xy);
- float alpha = 1.0 - smoothstep(0.0, 1.0, dist);
- gl_FragColor = outline_color * (alpha * opacity);
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* fill_outline::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x8d, 0x93, 0xcf, 0x4f, 0x83, 0x30,
+ 0x14, 0xc7, 0xef, 0xfc, 0x15, 0x2f, 0xd9, 0x85,
+ 0x29, 0x41, 0xb6, 0xec, 0x46, 0x3c, 0x78, 0x31,
+ 0x7a, 0xf0, 0x47, 0x34, 0x9e, 0x5f, 0xea, 0x80,
+ 0xed, 0xc5, 0xae, 0x25, 0xac, 0x85, 0x2d, 0xc6,
+ 0xff, 0xdd, 0x16, 0xb0, 0x16, 0x08, 0x46, 0x2e,
+ 0x90, 0xd7, 0x4f, 0x5f, 0x3f, 0xfd, 0xb6, 0x30,
+ 0xa5, 0x2a, 0x7a, 0xd7, 0x2a, 0x87, 0x3a, 0xdf,
+ 0xae, 0x81, 0x61, 0x29, 0x8f, 0x69, 0x10, 0x68,
+ 0x41, 0x85, 0xac, 0x0e, 0x70, 0x60, 0x6a, 0x03,
+ 0x1a, 0xcd, 0xab, 0xa2, 0x53, 0xea, 0xca, 0x2d,
+ 0xab, 0xb1, 0x91, 0x15, 0xcf, 0x0c, 0x5d, 0xb3,
+ 0xea, 0x4c, 0x62, 0xd7, 0x95, 0xeb, 0xbe, 0x45,
+ 0xb0, 0xa0, 0x42, 0x64, 0x79, 0x01, 0x77, 0x37,
+ 0xaf, 0xf8, 0xf6, 0x78, 0x7f, 0xfb, 0xf4, 0xf2,
+ 0x80, 0x1a, 0xa5, 0x56, 0x9c, 0x44, 0x8e, 0x5b,
+ 0xc9, 0x65, 0xe5, 0x1a, 0x72, 0xd9, 0x94, 0x50,
+ 0x70, 0xc9, 0x94, 0x51, 0x18, 0x20, 0xa8, 0xd2,
+ 0x80, 0x39, 0xc9, 0x3d, 0xed, 0xf6, 0xa5, 0x5d,
+ 0x67, 0x33, 0xe6, 0x52, 0x67, 0xe1, 0x31, 0x23,
+ 0x62, 0x91, 0xf3, 0x63, 0xee, 0xd6, 0xf4, 0x38,
+ 0x8d, 0x13, 0x52, 0x64, 0x54, 0xcc, 0x6f, 0xa2,
+ 0x64, 0x5b, 0x52, 0xe7, 0x19, 0xfd, 0x6e, 0x70,
+ 0x28, 0xde, 0x12, 0x7d, 0xc4, 0x3d, 0xf0, 0x6b,
+ 0xec, 0x4d, 0x77, 0x63, 0x43, 0x57, 0x8f, 0xd0,
+ 0xe8, 0x31, 0xbd, 0x65, 0x2d, 0x29, 0x33, 0x67,
+ 0x45, 0x22, 0x5c, 0xc2, 0x67, 0x00, 0xe6, 0xf9,
+ 0x57, 0xfa, 0x16, 0x1c, 0x54, 0xe0, 0x1a, 0xb4,
+ 0x30, 0xdd, 0x3f, 0xf0, 0x40, 0x27, 0xb4, 0xd1,
+ 0x84, 0xa3, 0x98, 0xa3, 0xe9, 0xf9, 0x2c, 0x7f,
+ 0x64, 0x6d, 0xbb, 0xb9, 0xf0, 0x6d, 0xe7, 0xb9,
+ 0x90, 0xff, 0xf2, 0xed, 0x83, 0x6e, 0x4d, 0xbb,
+ 0xef, 0x89, 0xe3, 0x3a, 0x74, 0x91, 0x46, 0x7e,
+ 0xfc, 0x03, 0xaf, 0x69, 0xc4, 0x9d, 0xd1, 0x24,
+ 0x4a, 0x0b, 0xef, 0x38, 0x3e, 0xcb, 0x23, 0x29,
+ 0x92, 0xa2, 0xa5, 0xba, 0xeb, 0x0f, 0x17, 0xd0,
+ 0x27, 0x62, 0x2e, 0x78, 0x04, 0x49, 0x04, 0x2b,
+ 0xb3, 0x84, 0xe5, 0xdb, 0x2b, 0x6f, 0xc8, 0xd0,
+ 0x9b, 0x18, 0x9f, 0xce, 0x70, 0xe5, 0x77, 0x8a,
+ 0x1b, 0xb8, 0x84, 0x55, 0x9c, 0x2c, 0x4d, 0x79,
+ 0x1d, 0x27, 0xa6, 0x9b, 0xfb, 0x81, 0xbe, 0x82,
+ 0x6f, 0xd3, 0x48, 0x35, 0x91
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* fill_outline::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x85, 0x90, 0x5f, 0x4f, 0x83, 0x30,
+ 0x14, 0xc5, 0xdf, 0xfb, 0x29, 0x6e, 0xb2, 0x17,
+ 0x58, 0x26, 0x41, 0xe3, 0x1b, 0xf1, 0x61, 0x99,
+ 0x5b, 0xdc, 0x83, 0xc3, 0x30, 0x75, 0x8f, 0x4d,
+ 0x03, 0x05, 0x9a, 0x94, 0xb6, 0x81, 0x0e, 0x25,
+ 0xc6, 0xef, 0x6e, 0x3b, 0xfe, 0x84, 0x6d, 0xa2,
+ 0x7d, 0xbc, 0xfd, 0x9d, 0x73, 0xee, 0xb9, 0x68,
+ 0xc6, 0x52, 0x91, 0xd0, 0x14, 0x9e, 0x96, 0x7b,
+ 0xfc, 0xb6, 0xdb, 0x6e, 0xc2, 0xe8, 0x19, 0x1f,
+ 0xb1, 0x3c, 0x6a, 0xce, 0x04, 0xc5, 0xb1, 0xe4,
+ 0xb2, 0x44, 0x35, 0x29, 0x1b, 0x26, 0x32, 0xc8,
+ 0x59, 0x96, 0x2b, 0xa8, 0x69, 0x7c, 0x0f, 0x67,
+ 0x40, 0x80, 0x66, 0x94, 0x57, 0x14, 0x1d, 0x05,
+ 0x4b, 0x65, 0x59, 0x8c, 0xb9, 0x0b, 0x2b, 0x4b,
+ 0x8a, 0x84, 0xa5, 0x08, 0xa1, 0x89, 0x60, 0x45,
+ 0x62, 0xa6, 0x9b, 0x21, 0x92, 0xcb, 0x0f, 0x05,
+ 0x29, 0x97, 0x44, 0x43, 0xf7, 0x75, 0x19, 0x36,
+ 0x22, 0x06, 0xf9, 0x28, 0xa6, 0x37, 0x32, 0xdb,
+ 0xdc, 0x41, 0x8d, 0x95, 0xac, 0x02, 0x33, 0x94,
+ 0x2c, 0x81, 0x82, 0x30, 0xe1, 0xb8, 0xf0, 0x85,
+ 0xc0, 0x3c, 0xbb, 0xce, 0x7f, 0x67, 0xb0, 0xdc,
+ 0xd4, 0x09, 0xe0, 0x61, 0xba, 0xea, 0x1f, 0xfe,
+ 0x5d, 0x5b, 0x4b, 0x5c, 0x37, 0x6d, 0x3d, 0xaf,
+ 0x1a, 0x59, 0xb8, 0xe5, 0x12, 0x56, 0x69, 0x03,
+ 0x71, 0x2a, 0x32, 0x9d, 0x3b, 0xa7, 0x72, 0x70,
+ 0x03, 0x19, 0xc7, 0x9b, 0x92, 0x64, 0x2b, 0x29,
+ 0xcb, 0xc4, 0xfb, 0x6c, 0xdc, 0x60, 0xa4, 0x20,
+ 0x5c, 0xe5, 0xc4, 0x48, 0x6e, 0x3d, 0xdf, 0x90,
+ 0x55, 0x21, 0xa5, 0xce, 0x2b, 0x4d, 0x95, 0xe3,
+ 0x7b, 0xfe, 0xc2, 0x4e, 0x17, 0x27, 0xd3, 0x4e,
+ 0x33, 0x38, 0xb5, 0x05, 0xcf, 0x0b, 0xcf, 0xc1,
+ 0x69, 0xdd, 0xe6, 0xfd, 0xbe, 0x46, 0xd5, 0xd7,
+ 0x0c, 0xdf, 0xd7, 0xd1, 0x63, 0xb4, 0x3c, 0xe0,
+ 0xed, 0x6e, 0xff, 0xb2, 0x5e, 0xbd, 0x86, 0xd1,
+ 0x6f, 0x86, 0xf6, 0x8c, 0x8e, 0x09, 0x75, 0x87,
+ 0x76, 0xdf, 0xe8, 0x07, 0x2a, 0x68, 0xd6, 0xbe
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_outline_pattern.cpp b/src/mbgl/shaders/fill_outline_pattern.cpp
index 11cddb7d07..b1a19afee5 100644
--- a/src/mbgl/shaders/fill_outline_pattern.cpp
+++ b/src/mbgl/shaders/fill_outline_pattern.cpp
@@ -1,107 +1,128 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/fill_outline_pattern.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* fill_outline_pattern::name = "fill_outline_pattern";
-const char* fill_outline_pattern::vertexSource = R"MBGL_SHADER(
-uniform mat4 u_matrix;
-uniform vec2 u_world;
-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;
-varying vec2 v_pos;
-
-
-#ifndef HAS_UNIFORM_u_opacity
-uniform lowp float a_opacity_t;
-attribute lowp vec2 a_opacity;
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-void main() {
-
-#ifndef HAS_UNIFORM_u_opacity
- opacity = unpack_mix_vec2(a_opacity, a_opacity_t);
-#else
- lowp float opacity = u_opacity;
-#endif
-
-
- 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);
-
- v_pos = (gl_Position.xy / gl_Position.w + 1.0) / 2.0 * u_world;
-}
-
-)MBGL_SHADER";
-const char* fill_outline_pattern::fragmentSource = R"MBGL_SHADER(
-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 sampler2D u_image;
-
-varying vec2 v_pos_a;
-varying vec2 v_pos_b;
-varying vec2 v_pos;
-
-
-#ifndef HAS_UNIFORM_u_opacity
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_opacity
- lowp float opacity = u_opacity;
-#endif
-
-
- 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);
-
- // find distance to outline for alpha interpolation
-
- float dist = length(v_pos - gl_FragCoord.xy);
- float alpha = 1.0 - smoothstep(0.0, 1.0, dist);
-
-
- gl_FragColor = mix(color1, color2, u_mix) * alpha * opacity;
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* fill_outline_pattern::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0xad, 0x93, 0xbd, 0x6e, 0x83, 0x30,
+ 0x14, 0x85, 0x77, 0x9e, 0xc2, 0x52, 0x17, 0xd2,
+ 0x22, 0x9a, 0x44, 0xd9, 0xa2, 0x0e, 0x5d, 0xaa,
+ 0x76, 0xe8, 0x8f, 0x5a, 0x75, 0xbe, 0x32, 0x60,
+ 0xa2, 0xab, 0x12, 0x1b, 0x19, 0x9b, 0x90, 0x56,
+ 0x7d, 0xf7, 0x5e, 0x03, 0x01, 0x52, 0x68, 0xb2,
+ 0x94, 0x05, 0x74, 0xee, 0x31, 0xe7, 0xb3, 0x39,
+ 0x58, 0x89, 0xa9, 0xd2, 0x5b, 0xb6, 0xe5, 0x66,
+ 0xc5, 0x2c, 0xd0, 0x4d, 0x63, 0xb5, 0xf6, 0x6c,
+ 0x2b, 0x97, 0x22, 0x5e, 0x92, 0xbc, 0x53, 0x3a,
+ 0x4b, 0x46, 0x6a, 0xce, 0x8d, 0x11, 0x5a, 0x42,
+ 0x81, 0x9f, 0x02, 0xf8, 0xe9, 0x71, 0x34, 0x1e,
+ 0x63, 0x25, 0x32, 0x88, 0x95, 0xd2, 0x09, 0xd8,
+ 0x3c, 0x17, 0xfa, 0xa4, 0x23, 0x53, 0xbb, 0xa1,
+ 0x23, 0xcd, 0x14, 0x37, 0x64, 0x29, 0x62, 0x9e,
+ 0x1d, 0x65, 0x1f, 0x0f, 0xa2, 0xf1, 0xc0, 0x20,
+ 0xe9, 0x24, 0x9a, 0x02, 0x8c, 0x6a, 0x22, 0x8a,
+ 0xb5, 0xe7, 0x11, 0xab, 0xc6, 0xc8, 0x1a, 0xd1,
+ 0x84, 0x73, 0xc8, 0x95, 0x93, 0x4b, 0xae, 0xf7,
+ 0x28, 0x37, 0x8d, 0x58, 0x3a, 0xd1, 0x85, 0x4d,
+ 0xa8, 0xd1, 0x94, 0x4a, 0x2f, 0xf0, 0x2e, 0x30,
+ 0x95, 0x89, 0x48, 0xd9, 0xfd, 0xed, 0x1b, 0xbc,
+ 0x3f, 0x3d, 0xdc, 0x3d, 0xbf, 0x3e, 0x82, 0x05,
+ 0x95, 0xf3, 0x18, 0xcd, 0xbe, 0xa3, 0xa3, 0xed,
+ 0xe5, 0x2d, 0x22, 0x3f, 0x0c, 0xc1, 0xac, 0x07,
+ 0x58, 0xb5, 0xa3, 0x65, 0x6b, 0x0d, 0x7d, 0xe4,
+ 0x60, 0x79, 0x37, 0xbb, 0xa0, 0x8d, 0x89, 0xa9,
+ 0x00, 0x0b, 0x03, 0x8f, 0x4c, 0x30, 0x25, 0xca,
+ 0x52, 0x61, 0x42, 0x1d, 0x40, 0xe9, 0xcf, 0xd8,
+ 0x97, 0xc7, 0xe8, 0x3a, 0x03, 0xee, 0x2c, 0xed,
+ 0x33, 0xbb, 0x61, 0x56, 0xd2, 0xe3, 0x07, 0x6c,
+ 0xb1, 0x02, 0x87, 0xe8, 0x77, 0x88, 0xc1, 0x70,
+ 0x3b, 0xb3, 0x03, 0x94, 0x5b, 0x3c, 0x46, 0x76,
+ 0xef, 0x99, 0x40, 0x73, 0xe6, 0x4d, 0x06, 0x2f,
+ 0xaa, 0x40, 0x83, 0x4a, 0xd6, 0xae, 0xa6, 0xa6,
+ 0xec, 0xd2, 0x1d, 0xc8, 0xca, 0xaf, 0x3f, 0x56,
+ 0xc0, 0xe6, 0x01, 0x5b, 0x50, 0x44, 0xbd, 0xa0,
+ 0xfd, 0x54, 0x64, 0xde, 0x08, 0xd3, 0x35, 0x91,
+ 0x34, 0x7f, 0xa2, 0x78, 0xc1, 0x54, 0xd7, 0x82,
+ 0xbe, 0x5d, 0x94, 0xf3, 0xbb, 0xec, 0xc1, 0x1f,
+ 0x4d, 0x0a, 0x9a, 0xe6, 0x10, 0x46, 0x4f, 0x11,
+ 0xfd, 0x0b, 0x45, 0x34, 0xa6, 0x88, 0xce, 0x53,
+ 0xf4, 0x18, 0x04, 0xe1, 0x0f, 0x8e, 0x31, 0xac,
+ 0xf6, 0xec, 0x7a, 0x78, 0xae, 0xe1, 0x8e, 0x5d,
+ 0xb1, 0x45, 0x38, 0x9f, 0x91, 0xbc, 0x0c, 0xe7,
+ 0x75, 0x5a, 0xfb, 0xdb, 0x7f, 0x7b, 0x3f, 0xaa,
+ 0x6d, 0x77, 0x06
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* fill_outline_pattern::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x7d, 0x53, 0x4b, 0x6f, 0xdb, 0x30,
+ 0x0c, 0xbe, 0xfb, 0x57, 0x10, 0xe8, 0xc5, 0x29,
+ 0xbc, 0x24, 0x35, 0x76, 0x0b, 0x7a, 0x28, 0x9a,
+ 0x16, 0xeb, 0x61, 0xcd, 0x90, 0xee, 0x71, 0x14,
+ 0x64, 0x5b, 0x76, 0x04, 0xc8, 0xa2, 0x21, 0xcb,
+ 0x59, 0xb2, 0x61, 0xff, 0x7d, 0x94, 0xa5, 0xda,
+ 0xcb, 0xe2, 0xc4, 0x47, 0xf2, 0x7b, 0x91, 0x94,
+ 0x3b, 0x2d, 0x4b, 0x34, 0x35, 0xec, 0x45, 0x9e,
+ 0x42, 0xc7, 0x1a, 0x6e, 0xad, 0x30, 0x9a, 0x59,
+ 0xc5, 0xf8, 0x2a, 0xea, 0xa6, 0x9b, 0x99, 0xb9,
+ 0xd2, 0x24, 0x66, 0x76, 0x8d, 0x79, 0xde, 0xb4,
+ 0xe2, 0xd0, 0xca, 0x5f, 0x62, 0xac, 0x97, 0x0a,
+ 0xb9, 0xa5, 0x46, 0x2d, 0x0f, 0xab, 0x68, 0xa8,
+ 0xb6, 0xbc, 0x6e, 0x94, 0x30, 0xe9, 0x9a, 0x3a,
+ 0xb2, 0xe6, 0x15, 0x11, 0xa2, 0x3d, 0x37, 0x47,
+ 0xa9, 0x2b, 0xaf, 0xb4, 0x67, 0x0d, 0xb6, 0x2e,
+ 0xd9, 0x44, 0x35, 0x9b, 0xaa, 0x92, 0x40, 0x74,
+ 0x23, 0x4b, 0x5d, 0x88, 0x12, 0x3e, 0x3d, 0xbc,
+ 0xb1, 0x6f, 0xaf, 0x2f, 0xcf, 0x9b, 0xed, 0x67,
+ 0xd6, 0x31, 0x6c, 0x78, 0x2e, 0xed, 0x71, 0xe0,
+ 0x28, 0xfc, 0xd9, 0x84, 0x58, 0xa1, 0xb5, 0x8a,
+ 0x6e, 0x84, 0x6a, 0xc5, 0x90, 0xee, 0x1f, 0xc4,
+ 0x40, 0x77, 0x18, 0x5d, 0xc8, 0x92, 0x6c, 0xf6,
+ 0x28, 0x0b, 0xa8, 0xb9, 0xd4, 0xf1, 0x0c, 0x7e,
+ 0x47, 0x40, 0x9f, 0x73, 0xbe, 0x6c, 0xec, 0x10,
+ 0xe7, 0xa6, 0x70, 0x3f, 0x29, 0xee, 0xc0, 0xfd,
+ 0x54, 0xfd, 0x5a, 0x72, 0x44, 0x53, 0x10, 0xb2,
+ 0xc6, 0x22, 0x0e, 0x2b, 0x49, 0xe0, 0x6e, 0xbe,
+ 0x9c, 0xad, 0x46, 0x20, 0x55, 0x1d, 0x42, 0x1e,
+ 0xe2, 0xd3, 0x93, 0xc3, 0x62, 0xbc, 0x47, 0xf2,
+ 0xdf, 0xc5, 0x4f, 0x7b, 0xa3, 0xd5, 0xa8, 0xfb,
+ 0x11, 0x72, 0x54, 0x68, 0xee, 0x48, 0x9a, 0x70,
+ 0xb6, 0x33, 0x22, 0x5d, 0xc7, 0xe1, 0x58, 0x89,
+ 0xf3, 0x24, 0xe8, 0x54, 0x58, 0x96, 0x9d, 0xc4,
+ 0xcd, 0xa6, 0xe2, 0xa6, 0x53, 0x79, 0xb3, 0x2b,
+ 0x79, 0xb3, 0x4b, 0x79, 0x59, 0x76, 0x96, 0x38,
+ 0xbd, 0x98, 0x38, 0x7d, 0x8f, 0xbc, 0x58, 0x40,
+ 0x29, 0x75, 0x01, 0x85, 0x6c, 0x2d, 0xd7, 0xb9,
+ 0x00, 0x8b, 0x80, 0x9d, 0x55, 0x52, 0x0b, 0xa0,
+ 0x07, 0x00, 0x5c, 0x35, 0x3b, 0x0e, 0x52, 0x93,
+ 0x7d, 0x83, 0x8a, 0x5b, 0x89, 0xda, 0x13, 0xfd,
+ 0x01, 0x1d, 0x8d, 0x4c, 0x94, 0xd0, 0x95, 0xdd,
+ 0xf9, 0x39, 0xe1, 0x03, 0x54, 0x8a, 0x3d, 0x1b,
+ 0x5e, 0x3d, 0xba, 0x58, 0xf3, 0xc3, 0x31, 0xe4,
+ 0xf2, 0x0c, 0x2f, 0x78, 0xef, 0x56, 0x41, 0xc8,
+ 0xb6, 0x46, 0xb4, 0xbb, 0xd6, 0x8a, 0x26, 0x5e,
+ 0xce, 0x97, 0xfd, 0x82, 0x92, 0x5e, 0xd4, 0xe5,
+ 0xeb, 0x59, 0x83, 0x16, 0xcd, 0x13, 0x76, 0xe5,
+ 0xaf, 0x91, 0x84, 0x19, 0x13, 0xff, 0x47, 0xcd,
+ 0xe0, 0x36, 0x68, 0xdf, 0x8e, 0x6f, 0xf9, 0xfd,
+ 0x31, 0x6e, 0xbe, 0x3f, 0x6d, 0xd7, 0xdb, 0x87,
+ 0x1f, 0xec, 0xe5, 0xf5, 0xed, 0xcb, 0xd3, 0xe3,
+ 0xd7, 0xcd, 0x76, 0x4a, 0xdb, 0x2d, 0x2e, 0xf6,
+ 0x27, 0x0a, 0x6f, 0xf0, 0x4f, 0xf4, 0x17, 0x5b,
+ 0x20, 0x6a, 0x67
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/fill_pattern.cpp b/src/mbgl/shaders/fill_pattern.cpp
index a3817c4426..f556fc876e 100644
--- a/src/mbgl/shaders/fill_pattern.cpp
+++ b/src/mbgl/shaders/fill_pattern.cpp
@@ -1,96 +1,111 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/fill_pattern.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* fill_pattern::name = "fill_pattern";
-const char* fill_pattern::vertexSource = R"MBGL_SHADER(
-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;
-
-
-#ifndef HAS_UNIFORM_u_opacity
-uniform lowp float a_opacity_t;
-attribute lowp vec2 a_opacity;
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-void main() {
-
-#ifndef HAS_UNIFORM_u_opacity
- opacity = unpack_mix_vec2(a_opacity, a_opacity_t);
-#else
- lowp float opacity = u_opacity;
-#endif
-
-
- 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);
-}
-
-)MBGL_SHADER";
-const char* fill_pattern::fragmentSource = R"MBGL_SHADER(
-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 sampler2D u_image;
-
-varying vec2 v_pos_a;
-varying vec2 v_pos_b;
-
-
-#ifndef HAS_UNIFORM_u_opacity
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_opacity
- lowp float opacity = u_opacity;
-#endif
-
-
- 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) * opacity;
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* fill_pattern::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0xad, 0x92, 0xbd, 0x6e, 0x83, 0x30,
+ 0x14, 0x85, 0x77, 0x3f, 0x85, 0xa5, 0x2c, 0xa4,
+ 0xf2, 0xd0, 0x56, 0xd9, 0x50, 0x87, 0x2e, 0x55,
+ 0x3b, 0xf4, 0x47, 0xad, 0x3a, 0x5f, 0x19, 0x30,
+ 0xe8, 0xaa, 0xc4, 0x46, 0xc6, 0xa6, 0x49, 0xab,
+ 0xbe, 0x7b, 0xaf, 0x81, 0x10, 0x52, 0x48, 0xb2,
+ 0x94, 0x05, 0xeb, 0xdc, 0x63, 0xce, 0x67, 0x7c,
+ 0xbc, 0xc6, 0xdc, 0xd8, 0x35, 0x5f, 0x4b, 0xb7,
+ 0xe2, 0x1e, 0xe8, 0x65, 0x71, 0x13, 0x33, 0xdf,
+ 0xcb, 0x8d, 0x4a, 0xaf, 0x49, 0xae, 0xa4, 0x73,
+ 0xca, 0x6a, 0xa8, 0xf1, 0x4b, 0x81, 0x3c, 0x3d,
+ 0x4e, 0xa6, 0x63, 0xdc, 0xa8, 0x12, 0x52, 0x63,
+ 0x6c, 0x06, 0xbe, 0xaa, 0x94, 0x3d, 0xe9, 0x28,
+ 0xcd, 0xe7, 0xd8, 0x91, 0x97, 0x46, 0x3a, 0xb2,
+ 0xd4, 0xa9, 0x2c, 0x0f, 0xb2, 0x0f, 0x07, 0xc9,
+ 0x74, 0xe0, 0x90, 0x74, 0x12, 0x5d, 0x0d, 0xce,
+ 0x74, 0x11, 0x75, 0xcc, 0x18, 0xb1, 0x5a, 0x4c,
+ 0xbc, 0x53, 0x5d, 0xb8, 0x84, 0xca, 0x04, 0xb9,
+ 0x91, 0x76, 0x8b, 0xba, 0xe8, 0xc4, 0x26, 0x88,
+ 0x21, 0x6c, 0x46, 0xa5, 0x24, 0xc6, 0x16, 0x98,
+ 0xeb, 0x4c, 0xe5, 0xfc, 0xfe, 0xf6, 0x0d, 0xde,
+ 0x9f, 0x1e, 0xee, 0x9e, 0x5f, 0x1f, 0xc1, 0x83,
+ 0xa9, 0x64, 0x8a, 0x6e, 0x3b, 0x90, 0xd0, 0x51,
+ 0xaa, 0x1e, 0x47, 0xee, 0x86, 0xe0, 0xe2, 0x11,
+ 0x42, 0xeb, 0xe8, 0x39, 0x7a, 0xc3, 0x3e, 0x74,
+ 0xb4, 0x7d, 0x98, 0x2d, 0xe8, 0x10, 0x6a, 0x2e,
+ 0xc0, 0xc3, 0xc8, 0xa3, 0x33, 0xcc, 0x89, 0xb2,
+ 0x31, 0x98, 0xd1, 0xcd, 0xa2, 0x8e, 0x96, 0xfc,
+ 0x9b, 0x71, 0x7a, 0xce, 0x80, 0x07, 0x4b, 0xbf,
+ 0xe6, 0x37, 0xdc, 0x6b, 0x5a, 0x7e, 0xc0, 0x1a,
+ 0x37, 0x10, 0x10, 0xa3, 0x01, 0x51, 0x8c, 0x8f,
+ 0xb3, 0xdc, 0x41, 0x85, 0xcd, 0x53, 0xe4, 0xf0,
+ 0x9d, 0x19, 0xb4, 0x60, 0x2e, 0x4a, 0x78, 0x31,
+ 0x35, 0x3a, 0x34, 0xba, 0x75, 0x75, 0xe5, 0xe3,
+ 0x17, 0xe1, 0x87, 0xac, 0xa2, 0xf6, 0x62, 0x04,
+ 0xbf, 0x14, 0xfc, 0x8a, 0x22, 0xda, 0x0d, 0xfd,
+ 0xb5, 0x90, 0xb9, 0x50, 0x6e, 0x68, 0x1d, 0x69,
+ 0xd1, 0x4c, 0xc9, 0xc4, 0x5c, 0xaf, 0xc4, 0xbe,
+ 0x49, 0x94, 0xf3, 0xb7, 0xd8, 0xe2, 0x48, 0x6b,
+ 0x44, 0xd7, 0x12, 0xc2, 0xd8, 0x53, 0x24, 0xff,
+ 0x42, 0x91, 0x4c, 0x29, 0x92, 0xf3, 0x14, 0x3f,
+ 0xec, 0x17, 0x9c, 0x8b, 0x53, 0x95
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* fill_pattern::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x7d, 0x92, 0xcd, 0x6e, 0x83, 0x30,
+ 0x10, 0x84, 0xef, 0x7e, 0x0a, 0x4b, 0xb9, 0x40,
+ 0x85, 0xda, 0x06, 0xf5, 0x86, 0x7a, 0x88, 0x42,
+ 0xa2, 0xe6, 0xd0, 0xa4, 0x22, 0xfd, 0x39, 0x5a,
+ 0x36, 0x18, 0x64, 0xc9, 0x60, 0x64, 0x0c, 0x4d,
+ 0x5a, 0xf5, 0xdd, 0x6b, 0x07, 0x07, 0x9a, 0xc6,
+ 0x09, 0xc7, 0x9d, 0xd9, 0x9d, 0x6f, 0xbd, 0xb4,
+ 0x15, 0xcb, 0x85, 0x2c, 0x61, 0x47, 0xd3, 0x10,
+ 0xb6, 0xa8, 0xc6, 0x4a, 0x51, 0x59, 0x21, 0xc5,
+ 0x11, 0x8e, 0x40, 0xeb, 0x16, 0x89, 0xbc, 0x22,
+ 0xea, 0x4e, 0x72, 0xad, 0xf3, 0x5c, 0x54, 0x74,
+ 0xd7, 0xb0, 0x2f, 0x3a, 0xd6, 0x73, 0x2e, 0xb0,
+ 0xd2, 0x42, 0xc9, 0x76, 0x11, 0x18, 0xaa, 0x0d,
+ 0x2e, 0x6b, 0x4e, 0x65, 0x18, 0x6b, 0x85, 0x95,
+ 0xb8, 0xd0, 0x0d, 0xa0, 0xc3, 0x72, 0xcf, 0xaa,
+ 0xa2, 0x9f, 0xd4, 0xa1, 0x5a, 0x34, 0x86, 0xcc,
+ 0x51, 0xd5, 0xa9, 0x00, 0x4c, 0x58, 0x5e, 0x65,
+ 0x34, 0x87, 0x4f, 0xb3, 0x2d, 0x7a, 0x5b, 0xaf,
+ 0x96, 0x9b, 0xe4, 0x19, 0xb5, 0x48, 0xd4, 0x38,
+ 0x65, 0x6a, 0x3f, 0x74, 0x71, 0xf1, 0x59, 0x5b,
+ 0x04, 0x2b, 0x45, 0x60, 0x42, 0x79, 0x43, 0x07,
+ 0x92, 0x3f, 0x8e, 0xa1, 0xdd, 0x78, 0xaa, 0x8c,
+ 0xe5, 0x3a, 0xa6, 0x13, 0x2c, 0x83, 0x25, 0x66,
+ 0x95, 0xe7, 0xc3, 0x6f, 0x00, 0xf5, 0x67, 0x92,
+ 0x2f, 0x07, 0x1b, 0xc7, 0x79, 0x28, 0x7c, 0x74,
+ 0x0e, 0x37, 0xe6, 0xc3, 0x5e, 0x87, 0x27, 0x48,
+ 0x85, 0x90, 0x99, 0x76, 0x96, 0x22, 0xf3, 0xec,
+ 0xfa, 0x01, 0x9c, 0xde, 0xde, 0xfb, 0xd1, 0x68,
+ 0xd4, 0x55, 0xe3, 0x60, 0x3b, 0xef, 0xf4, 0xbc,
+ 0xf0, 0x6e, 0x7c, 0xfb, 0xe0, 0xdf, 0x75, 0x4f,
+ 0xb5, 0x31, 0x6a, 0x9c, 0xfb, 0x00, 0x53, 0xc1,
+ 0x85, 0x9c, 0xea, 0xd1, 0xda, 0xa7, 0x5a, 0x49,
+ 0xc3, 0xd8, 0xb3, 0x87, 0x09, 0x4c, 0xa6, 0xb6,
+ 0xba, 0x60, 0x11, 0x39, 0xc1, 0x25, 0x2e, 0xdc,
+ 0xd0, 0xc5, 0x4b, 0xae, 0xf0, 0x92, 0x4b, 0xbc,
+ 0x88, 0x9c, 0x11, 0x87, 0x17, 0x89, 0xc3, 0x23,
+ 0x72, 0xc1, 0xd1, 0x52, 0xe2, 0x62, 0x6e, 0xec,
+ 0x16, 0xa5, 0x5f, 0x36, 0xb0, 0x23, 0x82, 0xfe,
+ 0xe7, 0xf4, 0xe1, 0xcd, 0xf8, 0x8b, 0x1c, 0x6f,
+ 0xbc, 0x79, 0x5f, 0x24, 0x71, 0x32, 0xfb, 0x40,
+ 0xab, 0xf5, 0xf6, 0x65, 0x31, 0x7f, 0xdd, 0x24,
+ 0xae, 0x99, 0x86, 0xc7, 0xeb, 0x37, 0xb7, 0xa7,
+ 0xfd, 0x01, 0xbf, 0x22, 0xc4, 0x2e, 0x6c
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/heatmap.cpp b/src/mbgl/shaders/heatmap.cpp
index 19927cfcc6..7d6f464428 100644
--- a/src/mbgl/shaders/heatmap.cpp
+++ b/src/mbgl/shaders/heatmap.cpp
@@ -1,128 +1,207 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/heatmap.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* heatmap::name = "heatmap";
-const char* heatmap::vertexSource = R"MBGL_SHADER(
-
-#ifndef HAS_UNIFORM_u_weight
-uniform lowp float a_weight_t;
-attribute highp vec2 a_weight;
-varying highp float weight;
-#else
-uniform highp float u_weight;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_radius
-uniform lowp float a_radius_t;
-attribute mediump vec2 a_radius;
-#else
-uniform mediump float u_radius;
-#endif
-
-
-uniform mat4 u_matrix;
-uniform float u_extrude_scale;
-uniform float u_opacity;
-uniform float u_intensity;
-
-attribute vec2 a_pos;
-
-varying vec2 v_extrude;
-
-// Effective "0" in the kernel density texture to adjust the kernel size to;
-// this empirically chosen number minimizes artifacts on overlapping kernels
-// for typical heatmap cases (assuming clustered source)
-const highp float ZERO = 1.0 / 255.0 / 16.0;
-
-// Gaussian kernel coefficient: 1 / sqrt(2 * PI)
-#define GAUSS_COEF 0.3989422804014327
-
-void main(void) {
-
-#ifndef HAS_UNIFORM_u_weight
- weight = unpack_mix_vec2(a_weight, a_weight_t);
-#else
- highp float weight = u_weight;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_radius
- mediump float radius = unpack_mix_vec2(a_radius, a_radius_t);
-#else
- mediump float radius = u_radius;
-#endif
-
-
- // unencode the extrusion vector that we snuck into the a_pos vector
- vec2 unscaled_extrude = vec2(mod(a_pos, 2.0) * 2.0 - 1.0);
-
- // This 'extrude' comes in ranging from [-1, -1], to [1, 1]. We'll use
- // it to produce the vertices of a square mesh framing the point feature
- // we're adding to the kernel density texture. We'll also pass it as
- // a varying, so that the fragment shader can determine the distance of
- // each fragment from the point feature.
- // Before we do so, we need to scale it up sufficiently so that the
- // kernel falls effectively to zero at the edge of the mesh.
- // That is, we want to know S such that
- // weight * u_intensity * GAUSS_COEF * exp(-0.5 * 3.0^2 * S^2) == ZERO
- // Which solves to:
- // S = sqrt(-2.0 * log(ZERO / (weight * u_intensity * GAUSS_COEF))) / 3.0
- float S = sqrt(-2.0 * log(ZERO / weight / u_intensity / GAUSS_COEF)) / 3.0;
-
- // Pass the varying in units of radius
- v_extrude = S * unscaled_extrude;
-
- // Scale by radius and the zoom-based scale factor to produce actual
- // mesh position
- vec2 extrude = v_extrude * radius * u_extrude_scale;
-
- // multiply a_pos by 0.5, since we had it * 2 in order to sneak
- // in extrusion data
- vec4 pos = vec4(floor(a_pos * 0.5) + extrude, 0, 1);
-
- gl_Position = u_matrix * pos;
-}
-
-)MBGL_SHADER";
-const char* heatmap::fragmentSource = R"MBGL_SHADER(
-
-#ifndef HAS_UNIFORM_u_weight
-varying highp float weight;
-#else
-uniform highp float u_weight;
-#endif
-
-
-uniform highp float u_intensity;
-varying vec2 v_extrude;
-
-// Gaussian kernel coefficient: 1 / sqrt(2 * PI)
-#define GAUSS_COEF 0.3989422804014327
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_weight
- highp float weight = u_weight;
-#endif
-
-
- // Kernel density estimation with a Gaussian kernel of size 5x5
- float d = -0.5 * 3.0 * 3.0 * dot(v_extrude, v_extrude);
- float val = weight * u_intensity * GAUSS_COEF * exp(d);
-
- gl_FragColor = vec4(val, 1.0, 1.0, 1.0);
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* heatmap::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x85, 0x56, 0xdb, 0x72, 0xdb, 0x36,
+ 0x14, 0x7c, 0xe7, 0x57, 0x9c, 0x89, 0x1f, 0x2c,
+ 0xa9, 0xba, 0x5b, 0x6e, 0x93, 0x78, 0xfc, 0x90,
+ 0x76, 0x9c, 0x34, 0x0f, 0xad, 0x3d, 0x51, 0x33,
+ 0x99, 0x69, 0x26, 0xd1, 0xc0, 0x04, 0x28, 0xa1,
+ 0x26, 0x01, 0x06, 0x17, 0xf9, 0xd2, 0xe9, 0xbf,
+ 0x77, 0x01, 0x12, 0x12, 0x1d, 0xb9, 0x6e, 0x5e,
+ 0xc4, 0xf0, 0x1c, 0x2c, 0xf6, 0x00, 0xbb, 0x4b,
+ 0x67, 0x47, 0xb2, 0x50, 0x5c, 0x14, 0xf4, 0xeb,
+ 0x9b, 0xe5, 0xea, 0xe3, 0xef, 0xef, 0xdf, 0x5e,
+ 0x7e, 0xf8, 0x6d, 0xe5, 0x57, 0xb7, 0x42, 0xae,
+ 0x37, 0x2e, 0xf3, 0x4a, 0x16, 0xda, 0x54, 0x54,
+ 0xea, 0xdb, 0x9a, 0x8a, 0x52, 0x33, 0x47, 0xac,
+ 0xad, 0xad, 0xdc, 0x59, 0xc6, 0x9c, 0x33, 0xf2,
+ 0xda, 0x3b, 0x41, 0x1b, 0xbc, 0xaa, 0x69, 0x2b,
+ 0xf2, 0xf9, 0xae, 0xe1, 0x2c, 0xdb, 0x32, 0x73,
+ 0x2f, 0xd5, 0xba, 0x2d, 0x36, 0xcb, 0x53, 0xed,
+ 0x48, 0x94, 0x56, 0xec, 0xf0, 0xbb, 0x1d, 0x7e,
+ 0xb5, 0xef, 0x51, 0x5c, 0x16, 0x59, 0x96, 0x3d,
+ 0xcd, 0xd1, 0x30, 0x2e, 0xbd, 0x7d, 0x9a, 0x63,
+ 0x53, 0x7b, 0xcc, 0xb1, 0x12, 0x78, 0x57, 0xed,
+ 0x58, 0x36, 0x2d, 0xdf, 0x33, 0x49, 0x4d, 0x89,
+ 0xcb, 0xbe, 0xab, 0xe5, 0xb2, 0x6b, 0x64, 0x6e,
+ 0x81, 0x3a, 0x7e, 0x8c, 0xbc, 0x3b, 0xdb, 0xbd,
+ 0x4e, 0xeb, 0xc4, 0x9d, 0x33, 0x9e, 0x8b, 0x95,
+ 0xcd, 0x59, 0x29, 0x0e, 0xcb, 0xba, 0x66, 0xb9,
+ 0x74, 0xf7, 0x87, 0x05, 0xa9, 0x9c, 0x50, 0x36,
+ 0x96, 0x3a, 0xd4, 0x5b, 0xca, 0xb5, 0x06, 0x93,
+ 0xdd, 0xb1, 0xc6, 0x97, 0xdb, 0xb4, 0x13, 0x0a,
+ 0x93, 0x09, 0x5d, 0x14, 0x85, 0xc8, 0x9d, 0xdc,
+ 0x0a, 0x7a, 0x31, 0x7d, 0x41, 0x52, 0x91, 0xdb,
+ 0x08, 0xba, 0x11, 0x46, 0x89, 0x92, 0x78, 0x03,
+ 0x4c, 0x0e, 0x2b, 0xbc, 0x11, 0xe4, 0x34, 0x31,
+ 0xfe, 0x97, 0xb7, 0xae, 0xdb, 0x64, 0xe5, 0x43,
+ 0xa8, 0x9c, 0x05, 0x30, 0xb7, 0x91, 0x96, 0x44,
+ 0x55, 0x4b, 0x23, 0x31, 0x45, 0x79, 0x4f, 0xf9,
+ 0x46, 0x5b, 0xa1, 0x48, 0xf9, 0xea, 0x5a, 0x18,
+ 0xaa, 0xa4, 0x92, 0x15, 0xda, 0x2d, 0x31, 0xe3,
+ 0x64, 0xc1, 0x72, 0x67, 0x49, 0x2b, 0xd2, 0x5b,
+ 0x61, 0x4a, 0x56, 0xd7, 0x81, 0x62, 0x03, 0x6a,
+ 0x03, 0x18, 0xa6, 0x24, 0x77, 0x5f, 0x07, 0x24,
+ 0xda, 0x08, 0xe6, 0x2a, 0x56, 0x53, 0xce, 0x2c,
+ 0x56, 0xf7, 0x98, 0xb5, 0xbe, 0x0a, 0xed, 0x79,
+ 0x09, 0x36, 0xc2, 0x08, 0x4e, 0x56, 0x7b, 0x93,
+ 0x8b, 0x7e, 0x96, 0x6b, 0x05, 0x7e, 0x5d, 0x79,
+ 0xfc, 0x79, 0xf1, 0xe1, 0x92, 0xce, 0x69, 0x36,
+ 0x9e, 0xd2, 0x84, 0xe6, 0xa7, 0xa7, 0xf1, 0x77,
+ 0xf6, 0xe3, 0x78, 0xda, 0x1c, 0xc0, 0x3b, 0xe6,
+ 0xad, 0x95, 0x4c, 0xa5, 0x79, 0x72, 0x2d, 0x8a,
+ 0x42, 0xe6, 0x52, 0x28, 0xf7, 0x9a, 0x66, 0x68,
+ 0xb5, 0xdf, 0x8c, 0xeb, 0xcd, 0x69, 0x40, 0x57,
+ 0xef, 0xfb, 0xd9, 0x11, 0x54, 0x25, 0x95, 0xa0,
+ 0x77, 0x6f, 0x3e, 0x2e, 0x97, 0xab, 0x5f, 0x2e,
+ 0x2f, 0xde, 0xd2, 0x74, 0x7c, 0xf2, 0xea, 0xe5,
+ 0xab, 0xc5, 0x7c, 0xfe, 0x72, 0xba, 0x98, 0xce,
+ 0x16, 0x27, 0xf3, 0x9f, 0x70, 0xe2, 0x5a, 0x72,
+ 0x5c, 0xb8, 0x54, 0xbd, 0xf0, 0xd4, 0xa7, 0xbf,
+ 0x33, 0xc2, 0xbf, 0xec, 0x59, 0xeb, 0x84, 0x8e,
+ 0xe6, 0x11, 0x6c, 0xbd, 0xc2, 0x7d, 0xdf, 0xac,
+ 0x2a, 0x79, 0xb7, 0x0a, 0xb7, 0xd6, 0x4b, 0x1e,
+ 0x19, 0x76, 0xec, 0xd4, 0x4f, 0x52, 0x0c, 0x2b,
+ 0x0f, 0x2d, 0x13, 0x50, 0x0e, 0x9c, 0xf1, 0x0c,
+ 0x8d, 0xd6, 0x1d, 0xa1, 0xe3, 0xb1, 0xa6, 0x9b,
+ 0xc2, 0x93, 0xa4, 0x9a, 0xd2, 0xb0, 0xe3, 0x9f,
+ 0x47, 0xa4, 0xfe, 0x0b, 0xe7, 0xd0, 0x24, 0xa1,
+ 0x1b, 0x97, 0xe1, 0x95, 0x50, 0xb9, 0xe6, 0x22,
+ 0x0a, 0x2c, 0xea, 0xd4, 0x4a, 0x28, 0x04, 0xbb,
+ 0xb9, 0xa0, 0x86, 0x4d, 0x1c, 0x8e, 0xac, 0xf2,
+ 0xf9, 0x0d, 0xb4, 0x0a, 0x3d, 0x86, 0xbe, 0x28,
+ 0xf3, 0xb6, 0x27, 0x02, 0x45, 0x9d, 0x7b, 0x15,
+ 0x9d, 0xc4, 0x93, 0xdc, 0xb1, 0x6f, 0x24, 0x5d,
+ 0x69, 0xde, 0x8b, 0x2b, 0x86, 0x34, 0x1f, 0x4f,
+ 0xfb, 0xb8, 0x57, 0xfc, 0xd0, 0x28, 0xe8, 0x03,
+ 0xdc, 0x13, 0x91, 0x3f, 0x82, 0x92, 0x8f, 0xdb,
+ 0xa5, 0xc7, 0x10, 0x45, 0x05, 0xdd, 0xc1, 0x1d,
+ 0x86, 0xa9, 0x75, 0x10, 0x5e, 0x61, 0x74, 0x45,
+ 0x9f, 0x47, 0xb3, 0x21, 0x8d, 0x66, 0x5f, 0x86,
+ 0xc1, 0x19, 0x9f, 0xf1, 0x3c, 0xfb, 0x32, 0x26,
+ 0xfa, 0x24, 0x8e, 0xcb, 0x92, 0x7c, 0x7b, 0x04,
+ 0xc0, 0x92, 0x2e, 0xd4, 0x6b, 0xa3, 0xb9, 0xcf,
+ 0x9b, 0xc9, 0x20, 0x78, 0x27, 0x73, 0x20, 0xea,
+ 0x82, 0x18, 0x04, 0xe6, 0x99, 0x09, 0x69, 0x63,
+ 0x37, 0xc0, 0x65, 0x51, 0xd8, 0xa1, 0xab, 0xd6,
+ 0x18, 0x91, 0x0a, 0x48, 0x1f, 0xe6, 0x4b, 0x60,
+ 0xb7, 0xe2, 0x18, 0xbd, 0x8c, 0xf3, 0xd8, 0xa5,
+ 0x9f, 0xb1, 0xeb, 0x8e, 0x0a, 0x2b, 0x2d, 0xb6,
+ 0x87, 0x67, 0x02, 0x13, 0x66, 0x13, 0x12, 0xa3,
+ 0x36, 0x17, 0x86, 0x30, 0x4f, 0x73, 0xb6, 0x01,
+ 0x0c, 0x0c, 0xd6, 0x15, 0xc4, 0x4f, 0x76, 0xc3,
+ 0x38, 0x4c, 0x9b, 0xc3, 0x1a, 0x5c, 0xc0, 0x64,
+ 0x55, 0xd0, 0x7d, 0xe8, 0xe0, 0xd2, 0x3a, 0xa6,
+ 0x30, 0x8a, 0x2e, 0x12, 0x96, 0x60, 0xf9, 0x66,
+ 0xbf, 0x32, 0x1e, 0xce, 0xc1, 0x04, 0xe3, 0xd4,
+ 0xfc, 0xb3, 0x80, 0xb5, 0x45, 0xb8, 0x48, 0xae,
+ 0xb1, 0xf5, 0x30, 0x3c, 0x29, 0x01, 0x0f, 0x63,
+ 0x9c, 0x78, 0x67, 0x81, 0xa7, 0xaf, 0xc9, 0xfa,
+ 0x64, 0x44, 0x24, 0x49, 0x87, 0x62, 0xc2, 0x69,
+ 0xc7, 0x2e, 0x90, 0x34, 0x48, 0x9d, 0x94, 0x63,
+ 0xe8, 0x05, 0xce, 0x83, 0x30, 0x08, 0xab, 0x66,
+ 0x22, 0xc1, 0xd7, 0x81, 0x6b, 0x7c, 0x0e, 0x87,
+ 0x3c, 0xde, 0x5f, 0x32, 0x3a, 0xa4, 0x8d, 0x04,
+ 0x6e, 0x99, 0x8a, 0xd7, 0x74, 0xa3, 0xf4, 0x2d,
+ 0x2d, 0xb1, 0x37, 0x06, 0x0a, 0x1b, 0xee, 0xcf,
+ 0x3d, 0x7a, 0x6a, 0xd0, 0x4d, 0x5c, 0xfc, 0xaf,
+ 0x93, 0x03, 0x03, 0x08, 0xb6, 0xee, 0x8d, 0xa6,
+ 0xe3, 0x53, 0x3c, 0x9e, 0x8c, 0xa7, 0x5f, 0x43,
+ 0x66, 0x2c, 0xbf, 0xce, 0xfb, 0x74, 0x7e, 0x1e,
+ 0x43, 0x28, 0x41, 0x7d, 0xda, 0x48, 0x80, 0x5b,
+ 0x5d, 0x6e, 0xa1, 0x00, 0xa7, 0x5f, 0xa7, 0xf7,
+ 0x4b, 0x48, 0x34, 0x86, 0xcd, 0x28, 0x28, 0x72,
+ 0x80, 0xef, 0xd3, 0xba, 0x17, 0xc3, 0x6b, 0x42,
+ 0xbd, 0xff, 0xdd, 0xbe, 0xdf, 0xef, 0xa3, 0x0f,
+ 0xdb, 0x46, 0xb4, 0xc6, 0x70, 0xcf, 0x00, 0xb6,
+ 0x78, 0x93, 0x47, 0x78, 0x93, 0x47, 0x78, 0x0d,
+ 0xdc, 0xde, 0x12, 0x57, 0x41, 0x41, 0x51, 0xbd,
+ 0xed, 0xe7, 0x04, 0x76, 0xc0, 0xc7, 0xc8, 0x45,
+ 0x15, 0x77, 0xc2, 0x63, 0xdb, 0x71, 0xdc, 0x32,
+ 0x30, 0xfe, 0xce, 0x88, 0x7b, 0xc4, 0x65, 0xbc,
+ 0xec, 0xeb, 0xfb, 0x94, 0x0c, 0x4c, 0xf1, 0xb8,
+ 0xc1, 0x83, 0xd6, 0xd5, 0xe8, 0x1a, 0x51, 0xcf,
+ 0x5b, 0x3d, 0x84, 0x4f, 0x45, 0xf0, 0xff, 0xde,
+ 0x45, 0x78, 0xe1, 0x59, 0x99, 0x80, 0xa2, 0x75,
+ 0x60, 0x69, 0xe9, 0x90, 0x16, 0xfb, 0x08, 0xe8,
+ 0x38, 0x7f, 0xc7, 0x69, 0x90, 0x36, 0x1b, 0x1c,
+ 0x7e, 0x73, 0x77, 0x70, 0xbe, 0x74, 0xb2, 0x86,
+ 0x90, 0x9a, 0x64, 0x01, 0x41, 0x5c, 0x2a, 0x5c,
+ 0x22, 0x83, 0xe8, 0xa1, 0x15, 0x18, 0x23, 0x48,
+ 0x14, 0xc9, 0x11, 0xce, 0x40, 0x9b, 0x60, 0x93,
+ 0xa0, 0x5d, 0x25, 0xd8, 0xcd, 0xce, 0xf4, 0xaa,
+ 0x93, 0x5f, 0x9c, 0x39, 0x96, 0x68, 0x2d, 0x02,
+ 0xd1, 0x26, 0x8c, 0x16, 0x3d, 0xdc, 0x93, 0x36,
+ 0x4d, 0x1c, 0x01, 0x0e, 0xbb, 0xf4, 0xe9, 0x87,
+ 0x44, 0x7b, 0x48, 0x53, 0x24, 0x4a, 0xca, 0xa4,
+ 0x75, 0xb9, 0xba, 0x6a, 0x07, 0x8c, 0x09, 0xda,
+ 0xfc, 0x19, 0x81, 0x45, 0xf1, 0x13, 0xff, 0x4f,
+ 0xf6, 0x2f, 0x86, 0xd2, 0x1c, 0xf9
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* heatmap::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x75, 0x91, 0x51, 0x4f, 0xc2, 0x30,
+ 0x14, 0x85, 0xdf, 0xfb, 0x2b, 0x6e, 0xc2, 0xcb,
+ 0x20, 0x38, 0xc6, 0x18, 0x11, 0x5c, 0x7c, 0x20,
+ 0x08, 0x48, 0x8c, 0x8c, 0x6c, 0xa2, 0x8f, 0x4b,
+ 0x43, 0xbb, 0x71, 0xe3, 0x68, 0x71, 0x2b, 0x03,
+ 0x34, 0xfe, 0x77, 0x3b, 0x86, 0x80, 0x41, 0xfa,
+ 0x70, 0x93, 0xa6, 0xe7, 0xdc, 0x7b, 0xcf, 0x57,
+ 0x52, 0xc1, 0x48, 0x30, 0x1e, 0xc1, 0x63, 0x2f,
+ 0x08, 0x67, 0x93, 0xf1, 0xd0, 0xf3, 0x9f, 0xc3,
+ 0x75, 0xb8, 0xe1, 0x18, 0x2f, 0x14, 0xc9, 0x69,
+ 0xba, 0x43, 0x11, 0xc3, 0x42, 0xdf, 0x56, 0x10,
+ 0x25, 0x92, 0x2a, 0x28, 0x9f, 0x5c, 0x52, 0xe1,
+ 0x49, 0xc6, 0xc9, 0x5a, 0x60, 0x24, 0xd3, 0xe5,
+ 0x1f, 0xc5, 0xaf, 0xbd, 0xd0, 0x08, 0x86, 0x11,
+ 0x21, 0x57, 0x64, 0x28, 0x14, 0x17, 0x19, 0xaa,
+ 0x9d, 0x7b, 0x9c, 0x94, 0xf3, 0xb9, 0x0d, 0x79,
+ 0xc8, 0xb7, 0x2a, 0x5d, 0x33, 0xee, 0x12, 0xd2,
+ 0x68, 0xc0, 0x88, 0xae, 0xb3, 0x0c, 0xa9, 0x80,
+ 0x77, 0x9e, 0x0a, 0x9e, 0xc0, 0x5c, 0xf2, 0x28,
+ 0xc2, 0x39, 0x72, 0xa1, 0xee, 0xa0, 0x09, 0x0d,
+ 0xc8, 0x3e, 0x52, 0x65, 0xd8, 0x50, 0x83, 0xe9,
+ 0xb8, 0x4a, 0x2a, 0x3a, 0x0d, 0x0a, 0x0e, 0xa3,
+ 0xde, 0x2c, 0x08, 0xc2, 0xbe, 0x37, 0x18, 0x82,
+ 0x65, 0xb6, 0xba, 0x9d, 0xae, 0x63, 0xdb, 0x1d,
+ 0xcb, 0xb1, 0x9a, 0x4e, 0xcb, 0xbe, 0x25, 0x24,
+ 0x97, 0xc8, 0x60, 0x49, 0x51, 0x18, 0x55, 0xf8,
+ 0x22, 0xa0, 0x0f, 0xd1, 0x28, 0xae, 0x92, 0x28,
+ 0x04, 0x97, 0x14, 0xe0, 0xfe, 0xbf, 0xb0, 0x85,
+ 0x56, 0xaf, 0xfd, 0x54, 0x6e, 0xcb, 0xca, 0x88,
+ 0xc0, 0x33, 0x85, 0x4b, 0xaa, 0x50, 0x0a, 0xd8,
+ 0xa0, 0x5a, 0x00, 0xbd, 0xc8, 0x25, 0x23, 0xc8,
+ 0xf0, 0x93, 0x43, 0x7b, 0xdb, 0xde, 0xf7, 0x28,
+ 0x27, 0x31, 0x3d, 0xe4, 0xc6, 0x32, 0xdb, 0x3a,
+ 0x5e, 0xcb, 0xb4, 0x8e, 0x95, 0x49, 0x65, 0x1c,
+ 0x39, 0xd5, 0x4f, 0xc8, 0xaa, 0xee, 0x99, 0x37,
+ 0xa7, 0x89, 0x76, 0x1f, 0x76, 0xad, 0x9d, 0x13,
+ 0xd7, 0xb7, 0x33, 0x40, 0x35, 0xe0, 0xdb, 0x95,
+ 0xc1, 0xb4, 0x77, 0x6f, 0x8e, 0x93, 0x70, 0x98,
+ 0xd2, 0xb8, 0x2f, 0x13, 0x99, 0x6a, 0xbf, 0xfe,
+ 0x13, 0xc7, 0xd0, 0xad, 0xea, 0xd0, 0x34, 0xad,
+ 0x53, 0x29, 0xd4, 0x07, 0x64, 0xde, 0xeb, 0xc0,
+ 0x7f, 0xf0, 0x7b, 0x6f, 0xe1, 0x78, 0x12, 0x4c,
+ 0x07, 0xfd, 0x17, 0xcf, 0xbf, 0xda, 0xa7, 0x34,
+ 0x1e, 0x58, 0x7d, 0x93, 0x1f, 0x8f, 0x9c, 0xc6,
+ 0x07
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/heatmap_texture.cpp b/src/mbgl/shaders/heatmap_texture.cpp
index c5d35c48ae..da7c8eab32 100644
--- a/src/mbgl/shaders/heatmap_texture.cpp
+++ b/src/mbgl/shaders/heatmap_texture.cpp
@@ -1,42 +1,71 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/heatmap_texture.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* heatmap_texture::name = "heatmap_texture";
-const char* heatmap_texture::vertexSource = R"MBGL_SHADER(
-uniform mat4 u_matrix;
-uniform vec2 u_world;
-attribute vec2 a_pos;
-varying vec2 v_pos;
-
-void main() {
- gl_Position = u_matrix * vec4(a_pos * u_world, 0, 1);
-
- v_pos.x = a_pos.x;
- v_pos.y = 1.0 - a_pos.y;
-}
-
-)MBGL_SHADER";
-const char* heatmap_texture::fragmentSource = R"MBGL_SHADER(
-uniform sampler2D u_image;
-uniform sampler2D u_color_ramp;
-uniform float u_opacity;
-varying vec2 v_pos;
-
-void main() {
- float t = texture2D(u_image, v_pos).r;
- vec4 color = texture2D(u_color_ramp, vec2(t, 0.5));
- gl_FragColor = color * u_opacity;
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(0.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* heatmap_texture::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x4d, 0x8d, 0x41, 0x0a, 0x83, 0x30,
+ 0x10, 0x45, 0xf7, 0x73, 0x8a, 0x59, 0x6a, 0xb1,
+ 0xa2, 0xc5, 0x5d, 0xe8, 0x1d, 0x7a, 0x83, 0x90,
+ 0x56, 0x2b, 0x03, 0x9a, 0x94, 0x98, 0x44, 0x43,
+ 0xe9, 0xdd, 0x3b, 0x9a, 0x50, 0x3a, 0x9b, 0x99,
+ 0x79, 0x9f, 0xff, 0xbf, 0xd7, 0xf4, 0x34, 0x76,
+ 0xc6, 0x59, 0xb9, 0x0e, 0xbd, 0xe4, 0x65, 0x69,
+ 0x13, 0xe0, 0x33, 0x0e, 0xc3, 0xe3, 0xc2, 0x78,
+ 0x35, 0x76, 0xea, 0x05, 0x28, 0xc7, 0xea, 0xdd,
+ 0xbb, 0x21, 0x71, 0x25, 0x5f, 0x66, 0x11, 0x10,
+ 0x94, 0x8d, 0xa4, 0xc7, 0xc4, 0x42, 0x62, 0x10,
+ 0x0c, 0xf5, 0x1c, 0x4a, 0xba, 0x28, 0xf1, 0x0d,
+ 0xc8, 0x33, 0x4e, 0xf2, 0x66, 0x16, 0x72, 0x64,
+ 0x34, 0x5e, 0x7f, 0x55, 0x78, 0xda, 0x7d, 0x5d,
+ 0x71, 0x64, 0xf1, 0x93, 0xbb, 0x2a, 0x6c, 0x2a,
+ 0x6c, 0x4b, 0x0e, 0xda, 0xad, 0x47, 0x68, 0xbd,
+ 0xb1, 0x4d, 0xa5, 0x4b, 0xfc, 0xe1, 0xc8, 0xb8,
+ 0xad, 0x1b, 0x3c, 0x67, 0x31, 0x0a, 0xf8, 0xc0,
+ 0x17, 0xe6, 0x77, 0x44, 0xb1
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* heatmap_texture::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x6d, 0x8e, 0x41, 0x0b, 0x82, 0x40,
+ 0x14, 0x84, 0xef, 0xfb, 0x2b, 0x1e, 0x78, 0xd1,
+ 0x10, 0x11, 0xa9, 0x93, 0x74, 0x08, 0x35, 0xe8,
+ 0x92, 0x61, 0x51, 0xc7, 0x65, 0xd1, 0xdd, 0x65,
+ 0x41, 0x5d, 0x59, 0x57, 0x49, 0xa2, 0xff, 0xde,
+ 0xa6, 0x82, 0x11, 0xbe, 0xe3, 0x9b, 0xf9, 0x66,
+ 0xa6, 0xab, 0x05, 0x93, 0xaa, 0x82, 0x96, 0x54,
+ 0x4d, 0x49, 0x55, 0x10, 0x43, 0x87, 0x45, 0x45,
+ 0x38, 0x0d, 0x51, 0xb7, 0x22, 0xe5, 0xb2, 0x94,
+ 0x0a, 0x2b, 0xf3, 0x59, 0x74, 0x56, 0x4a, 0xa2,
+ 0x8d, 0x26, 0x1b, 0x92, 0x0b, 0x3d, 0x84, 0xa8,
+ 0x27, 0x6a, 0x10, 0x35, 0x87, 0x9e, 0xe6, 0x01,
+ 0xf4, 0xb8, 0x91, 0x6d, 0x88, 0x50, 0x2f, 0x45,
+ 0x01, 0x15, 0x11, 0xb5, 0xed, 0xc0, 0x0b, 0x81,
+ 0xb9, 0x89, 0xd3, 0xb0, 0x07, 0x4d, 0x9f, 0xba,
+ 0x53, 0x34, 0x88, 0xed, 0xb9, 0xdc, 0x9d, 0x30,
+ 0xc7, 0x53, 0xe1, 0x68, 0x35, 0x49, 0x5b, 0x18,
+ 0xbb, 0xff, 0xdc, 0xcb, 0x1e, 0x77, 0xac, 0xb3,
+ 0xb5, 0x0b, 0xbe, 0xb7, 0x73, 0x9c, 0x89, 0xe3,
+ 0x25, 0x3e, 0x2a, 0xc2, 0xa3, 0x99, 0x9c, 0x12,
+ 0x36, 0xbf, 0x5b, 0x91, 0x25, 0x58, 0x41, 0x19,
+ 0xa4, 0xf7, 0x24, 0x8b, 0xb3, 0xc3, 0x03, 0x9f,
+ 0xce, 0xd7, 0x4b, 0x12, 0xdd, 0xd2, 0x6c, 0x2d,
+ 0xe0, 0xbb, 0xc3, 0xf6, 0x3d, 0xdf, 0xc4, 0x5b,
+ 0xb4, 0x2e, 0x04, 0x43, 0x6f, 0xf4, 0x01, 0x73,
+ 0x71, 0x68, 0xaa
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/hillshade.cpp b/src/mbgl/shaders/hillshade.cpp
index 4083faa4b4..1238cf812d 100644
--- a/src/mbgl/shaders/hillshade.cpp
+++ b/src/mbgl/shaders/hillshade.cpp
@@ -1,80 +1,193 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/hillshade.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* hillshade::name = "hillshade";
-const char* hillshade::vertexSource = R"MBGL_SHADER(
-uniform mat4 u_matrix;
-
-attribute vec2 a_pos;
-attribute vec2 a_texture_pos;
-
-varying vec2 v_pos;
-
-void main() {
- gl_Position = u_matrix * vec4(a_pos, 0, 1);
- v_pos = a_texture_pos / 8192.0;
-}
-
-)MBGL_SHADER";
-const char* hillshade::fragmentSource = R"MBGL_SHADER(
-uniform sampler2D u_image;
-varying vec2 v_pos;
-
-uniform vec2 u_latrange;
-uniform vec2 u_light;
-uniform vec4 u_shadow;
-uniform vec4 u_highlight;
-uniform vec4 u_accent;
-
-#define PI 3.141592653589793
-
-void main() {
- vec4 pixel = texture2D(u_image, v_pos);
-
- vec2 deriv = ((pixel.rg * 2.0) - 1.0);
-
- // We divide the slope by a scale factor based on the cosin of the pixel's approximate latitude
- // to account for mercator projection distortion. see #4807 for details
- float scaleFactor = cos(radians((u_latrange[0] - u_latrange[1]) * (1.0 - v_pos.y) + u_latrange[1]));
- // We also multiply the slope by an arbitrary z-factor of 1.25
- float slope = atan(1.25 * length(deriv) / scaleFactor);
- float aspect = deriv.x != 0.0 ? atan(deriv.y, -deriv.x) : PI / 2.0 * (deriv.y > 0.0 ? 1.0 : -1.0);
-
- float intensity = u_light.x;
- // We add PI to make this property match the global light object, which adds PI/2 to the light's azimuthal
- // position property to account for 0deg corresponding to north/the top of the viewport in the style spec
- // and the original shader was written to accept (-illuminationDirection - 90) as the azimuthal.
- float azimuth = u_light.y + PI;
-
- // We scale the slope exponentially based on intensity, using a calculation similar to
- // the exponential interpolation function in the style spec:
- // https://github.com/mapbox/mapbox-gl-js/blob/master/src/style-spec/expression/definitions/interpolate.js#L217-L228
- // so that higher intensity values create more opaque hillshading.
- float base = 1.875 - intensity * 1.75;
- float maxValue = 0.5 * PI;
- float scaledSlope = intensity != 0.5 ? ((pow(base, slope) - 1.0) / (pow(base, maxValue) - 1.0)) * maxValue : slope;
-
- // The accent color is calculated with the cosine of the slope while the shade color is calculated with the sine
- // so that the accent color's rate of change eases in while the shade color's eases out.
- float accent = cos(scaledSlope);
- // We multiply both the accent and shade color by a clamped intensity value
- // so that intensities >= 0.5 do not additionally affect the color values
- // while intensity values < 0.5 make the overall color more transparent.
- vec4 accent_color = (1.0 - accent) * u_accent * clamp(intensity * 2.0, 0.0, 1.0);
- float shade = abs(mod((aspect + azimuth) / PI + 0.5, 2.0) - 1.0);
- vec4 shade_color = mix(u_shadow, u_highlight, shade) * sin(scaledSlope) * clamp(intensity * 2.0, 0.0, 1.0);
- gl_FragColor = accent_color * (1.0 - shade_color.a) + shade_color;
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* hillshade::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x65, 0x8d, 0xc1, 0x0a, 0xc2, 0x30,
+ 0x10, 0x44, 0xef, 0xfb, 0x15, 0x73, 0x6c, 0xa5,
+ 0x68, 0x5b, 0x7a, 0x50, 0x82, 0xff, 0xe0, 0x1f,
+ 0x94, 0xa8, 0xb1, 0x2c, 0xd8, 0x44, 0xd2, 0x4d,
+ 0xa8, 0x88, 0xff, 0x6e, 0x4c, 0x51, 0x10, 0xf7,
+ 0xb2, 0xcb, 0xcc, 0xec, 0xbc, 0x60, 0xf9, 0xe2,
+ 0xfc, 0x88, 0x51, 0x4b, 0x87, 0xd0, 0xa7, 0xe5,
+ 0x79, 0x56, 0x44, 0x5a, 0xd2, 0x71, 0x0c, 0x62,
+ 0x10, 0xcd, 0xa9, 0x85, 0xee, 0x6f, 0x6e, 0x52,
+ 0xff, 0xaa, 0x98, 0x59, 0x82, 0x37, 0x8b, 0x4b,
+ 0x51, 0xfb, 0x3b, 0xdb, 0x61, 0x31, 0xe3, 0x47,
+ 0x74, 0x7c, 0x4e, 0xf5, 0x6c, 0x8b, 0x12, 0x0f,
+ 0x42, 0x9a, 0xe1, 0xda, 0x1f, 0xdc, 0xc4, 0xc2,
+ 0xce, 0x62, 0xff, 0x85, 0x62, 0xf5, 0xfe, 0xeb,
+ 0x8a, 0x8c, 0xaa, 0x50, 0x57, 0x68, 0x4a, 0x95,
+ 0xf3, 0xb9, 0x29, 0x25, 0x7f, 0x70, 0xd8, 0x60,
+ 0xdb, 0xec, 0xda, 0x75, 0xad, 0xe8, 0x49, 0x2f,
+ 0x97, 0x4d, 0x40, 0xaf
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* hillshade::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x8d, 0x56, 0xdb, 0x6e, 0xdb, 0x38,
+ 0x10, 0x7d, 0xf7, 0x57, 0x4c, 0x91, 0x87, 0x95,
+ 0x1b, 0x5b, 0x8a, 0x95, 0x78, 0x9d, 0xa4, 0x9b,
+ 0x16, 0x8b, 0xa6, 0x05, 0x02, 0x14, 0x6d, 0x90,
+ 0x16, 0xed, 0xc3, 0xa2, 0x30, 0x68, 0x89, 0x96,
+ 0x98, 0xa5, 0x44, 0x95, 0xa4, 0x7c, 0xe9, 0x62,
+ 0xff, 0xbd, 0x33, 0x24, 0x65, 0xcb, 0x4e, 0xb0,
+ 0xd8, 0xbc, 0x24, 0x21, 0x67, 0xce, 0x5c, 0xce,
+ 0x99, 0xa1, 0xda, 0x5a, 0x2c, 0x95, 0xae, 0xc0,
+ 0xb0, 0xaa, 0x91, 0x5c, 0xa7, 0xb7, 0xd0, 0xce,
+ 0x45, 0xc5, 0x0a, 0xfe, 0x6a, 0xb0, 0x62, 0x7a,
+ 0x2b, 0xea, 0x02, 0x56, 0x3c, 0x4b, 0x61, 0x35,
+ 0x6f, 0x94, 0x79, 0x35, 0x18, 0xb4, 0xc1, 0xde,
+ 0x1d, 0xb6, 0x73, 0xc9, 0xac, 0x66, 0x35, 0x59,
+ 0x1f, 0x5f, 0x88, 0xa2, 0xb4, 0x07, 0xa7, 0x17,
+ 0x78, 0x6a, 0x4a, 0x96, 0xab, 0xf5, 0x93, 0xe3,
+ 0x12, 0x8d, 0x9f, 0x77, 0x60, 0x59, 0xc6, 0x6b,
+ 0x3c, 0x1e, 0x9c, 0xe4, 0x7c, 0x29, 0x6a, 0x0e,
+ 0xf7, 0x77, 0x70, 0x1e, 0x4f, 0x2e, 0x26, 0xd3,
+ 0xab, 0xf4, 0xf7, 0xe9, 0xf9, 0xf4, 0xf2, 0x6a,
+ 0x76, 0x75, 0x3e, 0x18, 0xac, 0x94, 0xc8, 0xa1,
+ 0x62, 0xa2, 0x8e, 0x86, 0xf0, 0xcf, 0x00, 0xf0,
+ 0xc7, 0xf9, 0x37, 0x62, 0xc3, 0x25, 0xdc, 0x80,
+ 0xe5, 0x1b, 0xdb, 0x6a, 0x9e, 0xde, 0x46, 0xa1,
+ 0xb8, 0x91, 0xaf, 0x67, 0x88, 0xc0, 0xc1, 0x38,
+ 0x85, 0x9c, 0x6b, 0xb1, 0x42, 0xe3, 0x28, 0x72,
+ 0x6e, 0xb1, 0x2e, 0xe0, 0x25, 0xa4, 0xf1, 0xd9,
+ 0x10, 0xc6, 0x30, 0xc1, 0x5f, 0xc1, 0x36, 0x49,
+ 0xe0, 0x1b, 0x87, 0x5c, 0xac, 0x44, 0xce, 0xc1,
+ 0x96, 0x1c, 0x8c, 0x54, 0x0d, 0x87, 0xc5, 0x16,
+ 0x18, 0x98, 0x8c, 0x49, 0x0e, 0x4b, 0x96, 0x59,
+ 0xa5, 0x61, 0xc1, 0x0c, 0xcf, 0x41, 0xd5, 0xce,
+ 0x28, 0x53, 0x46, 0xd4, 0xa0, 0x96, 0xee, 0x1f,
+ 0x87, 0xff, 0x9b, 0x01, 0xd6, 0x34, 0x5a, 0x6d,
+ 0x30, 0x21, 0xcb, 0x01, 0x1b, 0x29, 0x6c, 0x9b,
+ 0xf3, 0x2e, 0x86, 0x55, 0x80, 0xb5, 0xab, 0xb6,
+ 0xb6, 0x80, 0xfd, 0x80, 0x8a, 0xeb, 0x8c, 0x11,
+ 0x2a, 0x7a, 0x3c, 0xf2, 0xcc, 0x0a, 0xc4, 0xcd,
+ 0x85, 0xc1, 0x13, 0xfa, 0x33, 0x06, 0xc3, 0x39,
+ 0x9c, 0x5c, 0x5c, 0x9e, 0xcd, 0x9c, 0x75, 0xce,
+ 0x2d, 0x13, 0xd2, 0x38, 0xac, 0xa5, 0x54, 0xcc,
+ 0xfa, 0xcc, 0xde, 0xfb, 0xc4, 0x6e, 0x28, 0x9b,
+ 0x48, 0xb3, 0x5c, 0xb0, 0xda, 0x44, 0xd1, 0x9e,
+ 0xc4, 0xbf, 0xce, 0xbe, 0x63, 0xad, 0xbd, 0xff,
+ 0x27, 0xdf, 0x87, 0xd8, 0x83, 0x08, 0xab, 0xc7,
+ 0x73, 0xd7, 0xb1, 0x78, 0x3b, 0x84, 0xd3, 0x23,
+ 0x13, 0xec, 0xcc, 0xbe, 0x31, 0x4c, 0x1a, 0x05,
+ 0x55, 0x2b, 0xad, 0x68, 0xe4, 0xf6, 0xa8, 0x3f,
+ 0x35, 0x30, 0xbd, 0x10, 0xe8, 0xa8, 0xb7, 0xf0,
+ 0x73, 0x1c, 0xda, 0x84, 0x3d, 0x99, 0xc4, 0xe9,
+ 0xb4, 0x9f, 0xab, 0x73, 0xb8, 0x01, 0x66, 0x59,
+ 0x1d, 0xd1, 0x1d, 0xe6, 0x20, 0x79, 0x5d, 0xd8,
+ 0x32, 0x72, 0x1c, 0x0d, 0x21, 0xe9, 0xd7, 0x13,
+ 0xc2, 0x7b, 0x5f, 0x66, 0x1a, 0xec, 0x0e, 0x3a,
+ 0x3b, 0xcb, 0x78, 0x03, 0x2f, 0x6e, 0xe0, 0x0c,
+ 0xd3, 0x7f, 0xe3, 0xd1, 0xfc, 0xe9, 0x76, 0x04,
+ 0xe3, 0x70, 0x3f, 0x84, 0x6b, 0x92, 0x54, 0x42,
+ 0x44, 0x53, 0xa9, 0xc1, 0x00, 0x5e, 0x07, 0x2f,
+ 0x2a, 0xfd, 0x1a, 0xc6, 0x3d, 0xfe, 0x7d, 0x1c,
+ 0x51, 0x5b, 0x5e, 0x1b, 0x61, 0xb7, 0x18, 0x2a,
+ 0x88, 0x3d, 0xde, 0x1c, 0xf4, 0x21, 0xcf, 0x09,
+ 0x18, 0x69, 0xac, 0xd8, 0xdf, 0x24, 0x14, 0x61,
+ 0x88, 0xbb, 0x86, 0x6b, 0xf4, 0x41, 0xc6, 0xb3,
+ 0xd2, 0x35, 0xa7, 0x90, 0x6a, 0xc1, 0x24, 0x38,
+ 0x00, 0x50, 0x0b, 0xa2, 0x76, 0x04, 0xeb, 0x52,
+ 0xe0, 0x35, 0x22, 0x18, 0x84, 0x48, 0x52, 0x02,
+ 0x21, 0x5b, 0x67, 0x44, 0xb2, 0xf9, 0x29, 0xaa,
+ 0xd6, 0x96, 0x4c, 0x76, 0xe1, 0x90, 0x17, 0xe1,
+ 0x14, 0xb1, 0x0b, 0x70, 0xa4, 0x9e, 0xb3, 0x9c,
+ 0x17, 0x48, 0xba, 0xd6, 0xdc, 0x34, 0xaa, 0xce,
+ 0x69, 0xa8, 0xd1, 0xa2, 0x46, 0xf1, 0x94, 0x09,
+ 0x21, 0x5b, 0xd5, 0x74, 0xda, 0x5c, 0x09, 0xbe,
+ 0x6e, 0xf0, 0x02, 0x2b, 0xf4, 0xec, 0xd9, 0x2d,
+ 0x4a, 0x9a, 0xba, 0xda, 0x45, 0x63, 0x75, 0xee,
+ 0x6e, 0x94, 0x16, 0x85, 0xa8, 0x31, 0x79, 0x1a,
+ 0x6a, 0xae, 0x61, 0xcd, 0x0c, 0xac, 0xb5, 0xb0,
+ 0xd8, 0x98, 0x10, 0x9f, 0x37, 0x16, 0xa2, 0xb1,
+ 0x90, 0xb2, 0xad, 0xd0, 0x90, 0x32, 0xbc, 0x15,
+ 0x3a, 0x88, 0x77, 0x0c, 0x57, 0x38, 0x59, 0xe8,
+ 0x42, 0x50, 0xbb, 0x8a, 0xe2, 0x3e, 0x95, 0xfe,
+ 0xb0, 0xd7, 0xe0, 0x2d, 0x4a, 0xef, 0xfe, 0xee,
+ 0x60, 0x0e, 0xfd, 0xc4, 0xed, 0x65, 0xc6, 0x37,
+ 0x58, 0x20, 0x6e, 0x0c, 0xc1, 0x24, 0xca, 0x6f,
+ 0x37, 0x82, 0x3b, 0xba, 0x46, 0xd0, 0x1a, 0x2a,
+ 0x9f, 0x01, 0x3a, 0x66, 0xad, 0x74, 0x59, 0x81,
+ 0x11, 0x95, 0x90, 0x4c, 0x63, 0xda, 0xbb, 0xf1,
+ 0x2b, 0x0f, 0xb0, 0x1c, 0x80, 0x6e, 0x54, 0xb0,
+ 0x5f, 0xb6, 0xb5, 0xaf, 0xe2, 0x49, 0x93, 0xae,
+ 0x3b, 0x80, 0xd2, 0xda, 0xc6, 0x5c, 0x27, 0x49,
+ 0x21, 0x6c, 0xd9, 0x2e, 0xe2, 0x4c, 0x55, 0x49,
+ 0xc5, 0x9a, 0x85, 0xda, 0x84, 0x5f, 0xe3, 0x42,
+ 0x8e, 0x1f, 0x4d, 0xb2, 0x40, 0xfe, 0xf1, 0xc4,
+ 0x20, 0x7a, 0x62, 0x74, 0x96, 0x38, 0xa4, 0x31,
+ 0x21, 0x25, 0x18, 0x1e, 0xf9, 0x32, 0x18, 0x26,
+ 0x71, 0xbb, 0xcf, 0x51, 0x6c, 0x92, 0x7d, 0x26,
+ 0x3c, 0x7e, 0x34, 0x27, 0x1f, 0xd2, 0xc9, 0x6c,
+ 0xfc, 0x21, 0x4d, 0x2f, 0xbb, 0xc0, 0x86, 0xc4,
+ 0x82, 0xed, 0xa3, 0x9d, 0x8a, 0xac, 0xec, 0x85,
+ 0xba, 0x62, 0xb2, 0xe5, 0x06, 0x32, 0xcd, 0x69,
+ 0xdf, 0x54, 0x4a, 0x23, 0x85, 0x0d, 0xfb, 0xd1,
+ 0x72, 0x34, 0x95, 0x92, 0x48, 0xc4, 0xc6, 0xf4,
+ 0x09, 0xa0, 0xee, 0x61, 0xf7, 0x27, 0xf1, 0xe5,
+ 0x6c, 0x8a, 0x7c, 0xed, 0x91, 0x5e, 0xe2, 0xd9,
+ 0x6c, 0xda, 0x1f, 0xbb, 0x8a, 0x6d, 0xbe, 0x12,
+ 0x3c, 0xd0, 0xb4, 0xd1, 0xbc, 0x12, 0x4d, 0x47,
+ 0xdb, 0x27, 0xff, 0x1c, 0xe6, 0x7a, 0x0f, 0xf4,
+ 0xc2, 0x9b, 0xbf, 0xa1, 0x9d, 0xab, 0xd6, 0x11,
+ 0x05, 0x1c, 0x79, 0x22, 0xbb, 0xa5, 0x8b, 0x93,
+ 0xd9, 0xbb, 0xea, 0xc2, 0x74, 0xb7, 0xb4, 0x9d,
+ 0x76, 0xa1, 0xaf, 0xbd, 0xe7, 0x5e, 0x1e, 0x5f,
+ 0x48, 0x59, 0xee, 0xfd, 0x40, 0xed, 0x4b, 0x1c,
+ 0x03, 0x1c, 0xc1, 0x8e, 0x75, 0x94, 0xc5, 0x1a,
+ 0x99, 0xd9, 0xef, 0x66, 0xde, 0x0d, 0x80, 0xd7,
+ 0x11, 0x8e, 0x60, 0xa7, 0x2b, 0x52, 0xf7, 0x7f,
+ 0x03, 0x90, 0xfb, 0x71, 0xfb, 0xed, 0x51, 0x70,
+ 0x9c, 0x5b, 0x4d, 0x7d, 0xc7, 0x28, 0x59, 0x49,
+ 0x9b, 0x13, 0x38, 0x96, 0x64, 0x48, 0x41, 0xcf,
+ 0xc6, 0x42, 0x7b, 0x6f, 0xa0, 0x5a, 0x7b, 0x30,
+ 0x15, 0x1e, 0xd3, 0xef, 0xf0, 0x5e, 0x5f, 0x0f,
+ 0x96, 0xf0, 0x6e, 0xff, 0x2e, 0x54, 0x48, 0x31,
+ 0xb8, 0xd1, 0xec, 0xf6, 0x0b, 0x72, 0xaf, 0x56,
+ 0x26, 0xf1, 0xed, 0xc7, 0x7a, 0x8e, 0xa4, 0x72,
+ 0x5c, 0x51, 0x77, 0x2d, 0x30, 0xa9, 0xd7, 0x9e,
+ 0xb8, 0x9c, 0x96, 0x88, 0xa5, 0x4d, 0xe5, 0xc4,
+ 0xe9, 0x66, 0x8e, 0x2d, 0x97, 0xb4, 0x81, 0x7d,
+ 0x63, 0x29, 0x86, 0xd7, 0x5d, 0x87, 0xe6, 0x8b,
+ 0x7d, 0xa2, 0xca, 0x3f, 0x1c, 0x5e, 0x58, 0x95,
+ 0xd8, 0xa5, 0x15, 0xd7, 0x88, 0x16, 0x10, 0x9c,
+ 0x56, 0xe9, 0xbd, 0x31, 0x0d, 0xd3, 0x58, 0x46,
+ 0xbc, 0x7f, 0xe1, 0x7d, 0x5d, 0x73, 0x6f, 0x77,
+ 0xd3, 0x3d, 0x55, 0xfe, 0x94, 0xd4, 0xd1, 0x7d,
+ 0x41, 0xe0, 0x9f, 0xae, 0xcc, 0xa8, 0xaf, 0x62,
+ 0xdc, 0xf9, 0x23, 0xda, 0xf3, 0xa3, 0xf0, 0xbe,
+ 0xf7, 0x04, 0xeb, 0x7a, 0x84, 0x4f, 0xd0, 0xc2,
+ 0x44, 0x95, 0xca, 0xa3, 0x28, 0xbc, 0x2b, 0xa7,
+ 0xdd, 0x56, 0x22, 0x61, 0xe2, 0x7a, 0x3f, 0xa5,
+ 0xb4, 0x47, 0x87, 0x5f, 0x09, 0xbb, 0xdc, 0x1c,
+ 0xc8, 0x2e, 0xb5, 0x4a, 0x6c, 0xa2, 0xee, 0x03,
+ 0x68, 0xd4, 0xff, 0xe6, 0x19, 0x79, 0x43, 0xca,
+ 0x16, 0x85, 0x74, 0xc0, 0xe9, 0xff, 0xce, 0xba,
+ 0x90, 0xf3, 0xf7, 0x9a, 0x15, 0x6f, 0x43, 0xac,
+ 0x83, 0xae, 0xec, 0x1e, 0xf0, 0x5e, 0x3e, 0x31,
+ 0xa3, 0x67, 0xbc, 0x77, 0x40, 0x5f, 0x58, 0x62,
+ 0x89, 0x7b, 0x06, 0x3e, 0x7d, 0x7d, 0xf7, 0x70,
+ 0xfb, 0xf0, 0xe7, 0xb7, 0xf9, 0xdd, 0xc7, 0xcf,
+ 0xf7, 0xef, 0xde, 0x7e, 0xf9, 0xf4, 0xf0, 0x5c,
+ 0x04, 0x2a, 0x30, 0xf2, 0xf1, 0x4f, 0x38, 0xbe,
+ 0x28, 0xcb, 0xc1, 0xbf, 0x83, 0x5f, 0x25, 0x18,
+ 0x54, 0xec
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/hillshade_prepare.cpp b/src/mbgl/shaders/hillshade_prepare.cpp
index 8d0571f6a4..d45942b476 100644
--- a/src/mbgl/shaders/hillshade_prepare.cpp
+++ b/src/mbgl/shaders/hillshade_prepare.cpp
@@ -1,100 +1,171 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/hillshade_prepare.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* hillshade_prepare::name = "hillshade_prepare";
-const char* hillshade_prepare::vertexSource = R"MBGL_SHADER(
-uniform mat4 u_matrix;
-
-attribute vec2 a_pos;
-attribute vec2 a_texture_pos;
-
-varying vec2 v_pos;
-
-void main() {
- gl_Position = u_matrix * vec4(a_pos, 0, 1);
- v_pos = (a_texture_pos / 8192.0) / 2.0 + 0.25;
-}
-
-)MBGL_SHADER";
-const char* hillshade_prepare::fragmentSource = R"MBGL_SHADER(
-#ifdef GL_ES
-precision highp float;
-#endif
-
-uniform sampler2D u_image;
-varying vec2 v_pos;
-uniform vec2 u_dimension;
-uniform float u_zoom;
-uniform float u_maxzoom;
-
-float getElevation(vec2 coord, float bias) {
- // Convert encoded elevation value to meters
- vec4 data = texture2D(u_image, coord) * 255.0;
- return (data.r + data.g * 256.0 + data.b * 256.0 * 256.0) / 4.0;
-}
-
-void main() {
- vec2 epsilon = 1.0 / u_dimension;
-
- // queried pixels:
- // +-----------+
- // | | | |
- // | a | b | c |
- // | | | |
- // +-----------+
- // | | | |
- // | d | e | f |
- // | | | |
- // +-----------+
- // | | | |
- // | g | h | i |
- // | | | |
- // +-----------+
-
- float a = getElevation(v_pos + vec2(-epsilon.x, -epsilon.y), 0.0);
- float b = getElevation(v_pos + vec2(0, -epsilon.y), 0.0);
- float c = getElevation(v_pos + vec2(epsilon.x, -epsilon.y), 0.0);
- float d = getElevation(v_pos + vec2(-epsilon.x, 0), 0.0);
- float e = getElevation(v_pos, 0.0);
- float f = getElevation(v_pos + vec2(epsilon.x, 0), 0.0);
- float g = getElevation(v_pos + vec2(-epsilon.x, epsilon.y), 0.0);
- float h = getElevation(v_pos + vec2(0, epsilon.y), 0.0);
- float i = getElevation(v_pos + vec2(epsilon.x, epsilon.y), 0.0);
-
- // here we divide the x and y slopes by 8 * pixel size
- // where pixel size (aka meters/pixel) is:
- // circumference of the world / (pixels per tile * number of tiles)
- // which is equivalent to: 8 * 40075016.6855785 / (512 * pow(2, u_zoom))
- // which can be reduced to: pow(2, 19.25619978527 - u_zoom)
- // we want to vertically exaggerate the hillshading though, because otherwise
- // it is barely noticeable at low zooms. to do this, we multiply this by some
- // scale factor pow(2, (u_zoom - u_maxzoom) * a) where a is an arbitrary value
- // Here we use a=0.3 which works out to the expression below. see
- // nickidlugash's awesome breakdown for more info
- // https://github.com/mapbox/mapbox-gl-js/pull/5286#discussion_r148419556
- float exaggeration = u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;
-
- vec2 deriv = vec2(
- (c + f + f + i) - (a + d + d + g),
- (g + h + h + i) - (a + b + b + c)
- ) / pow(2.0, (u_zoom - u_maxzoom) * exaggeration + 19.2562 - u_zoom);
-
- gl_FragColor = clamp(vec4(
- deriv.x / 2.0 + 0.5,
- deriv.y / 2.0 + 0.5,
- 1.0,
- 1.0), 0.0, 1.0);
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* hillshade_prepare::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x65, 0x4d, 0x51, 0x0a, 0xc2, 0x30,
+ 0x14, 0xfb, 0xef, 0x29, 0xf2, 0xb9, 0xe9, 0x98,
+ 0x5b, 0x99, 0xa0, 0x14, 0xef, 0xe0, 0x0d, 0x46,
+ 0xd5, 0x3a, 0x1e, 0xb8, 0x76, 0x74, 0xed, 0x98,
+ 0x88, 0x77, 0xf7, 0xd9, 0xa1, 0x20, 0xbe, 0x9f,
+ 0x84, 0x24, 0x2f, 0x89, 0x96, 0xae, 0xce, 0xf7,
+ 0xe8, 0x75, 0x68, 0x10, 0x5b, 0x06, 0x4f, 0xb3,
+ 0x12, 0x42, 0x07, 0x26, 0xa7, 0x18, 0x0c, 0x26,
+ 0x73, 0x96, 0xd0, 0xed, 0xe0, 0x46, 0xf5, 0xaf,
+ 0x06, 0x33, 0x87, 0xe8, 0xcd, 0xe2, 0x8a, 0x49,
+ 0xfb, 0x3b, 0xd9, 0x6e, 0x31, 0xa7, 0x8f, 0xe8,
+ 0xe8, 0xc2, 0xf5, 0x64, 0xb3, 0x1c, 0x0f, 0x01,
+ 0xbe, 0xee, 0xd6, 0x1e, 0xdd, 0x48, 0x81, 0x9c,
+ 0xc5, 0xe1, 0x3b, 0x8a, 0xd5, 0xfb, 0xaf, 0xc9,
+ 0xd2, 0x54, 0x81, 0xaa, 0x40, 0x9d, 0xab, 0x94,
+ 0x4f, 0x4d, 0x9c, 0xcc, 0x7e, 0xf6, 0xb0, 0xc1,
+ 0xae, 0xde, 0xcb, 0xb2, 0xca, 0x99, 0x31, 0x60,
+ 0x8d, 0xaa, 0x94, 0x5b, 0x25, 0x9e, 0xe2, 0x05,
+ 0x6f, 0x64, 0x43, 0x2f
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* hillshade_prepare::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0xad, 0x56, 0x6d, 0x6f, 0xdb, 0x36,
+ 0x10, 0xfe, 0xee, 0x5f, 0x71, 0x40, 0x3e, 0x4c,
+ 0x5e, 0x1c, 0x59, 0x56, 0xad, 0xbc, 0x2e, 0x18,
+ 0x86, 0x24, 0xdd, 0x06, 0x0c, 0xeb, 0x90, 0x0e,
+ 0xdb, 0x47, 0x83, 0x12, 0x4f, 0x12, 0x17, 0x4a,
+ 0x54, 0x49, 0xc9, 0x2f, 0xdd, 0xfa, 0xdf, 0x77,
+ 0xa4, 0x28, 0x2b, 0x69, 0xbc, 0x34, 0x05, 0x26,
+ 0xe0, 0x20, 0xfb, 0x78, 0xf7, 0xdc, 0x2b, 0xef,
+ 0x74, 0x24, 0x72, 0x8e, 0x39, 0xfc, 0xf8, 0xcb,
+ 0xea, 0xee, 0xfd, 0xa4, 0xd1, 0x98, 0x09, 0x23,
+ 0x54, 0x0d, 0xa5, 0x28, 0xca, 0x06, 0x72, 0xa9,
+ 0x58, 0x7b, 0x35, 0x39, 0xc2, 0x9a, 0x8b, 0x7c,
+ 0x32, 0xe9, 0x6a, 0x91, 0x2b, 0x5d, 0x81, 0x61,
+ 0x55, 0x23, 0x51, 0xc7, 0xb7, 0xd0, 0xad, 0x44,
+ 0xc5, 0x0a, 0xbc, 0x9a, 0xac, 0x99, 0xde, 0x89,
+ 0xba, 0x80, 0x35, 0x66, 0x31, 0xac, 0x57, 0x8d,
+ 0x32, 0x57, 0x7b, 0x71, 0xc7, 0xeb, 0x56, 0x5c,
+ 0x54, 0x58, 0x5b, 0xf0, 0xf1, 0xc4, 0xe1, 0xd3,
+ 0xd1, 0x47, 0xa5, 0xaa, 0xe7, 0xdc, 0x8a, 0x6d,
+ 0xfb, 0x83, 0x49, 0xcf, 0x29, 0xb0, 0xbd, 0x93,
+ 0xb8, 0x66, 0x2d, 0x61, 0x04, 0x0e, 0x34, 0x53,
+ 0x4a, 0xf3, 0x99, 0x57, 0x48, 0x05, 0x33, 0x53,
+ 0xf8, 0x7b, 0x02, 0xf4, 0xcc, 0xe7, 0x70, 0xa3,
+ 0xea, 0x35, 0xea, 0x16, 0xb0, 0xce, 0x14, 0x47,
+ 0x0e, 0x38, 0xa8, 0xc2, 0x9a, 0xc9, 0x0e, 0xa1,
+ 0x55, 0x50, 0x61, 0x8b, 0xda, 0x38, 0x05, 0x82,
+ 0x5b, 0x02, 0x67, 0x2d, 0x83, 0x6b, 0x68, 0x71,
+ 0xdb, 0x76, 0x1a, 0xe3, 0xdb, 0xc0, 0x87, 0x37,
+ 0xeb, 0x0d, 0x4d, 0xe1, 0x5b, 0x88, 0x93, 0x24,
+ 0x8c, 0xae, 0x9c, 0x8a, 0x46, 0x92, 0xaa, 0x21,
+ 0xb0, 0x5a, 0xa1, 0x86, 0x63, 0xa7, 0x1e, 0x16,
+ 0x4e, 0xe8, 0x34, 0x8c, 0x06, 0x46, 0xba, 0x67,
+ 0xf8, 0xf7, 0x14, 0xe6, 0xb0, 0xb4, 0x20, 0x9f,
+ 0x26, 0x93, 0xb5, 0x12, 0x1c, 0x2a, 0x26, 0xea,
+ 0x60, 0xf0, 0xdc, 0xc5, 0x85, 0x8d, 0x11, 0x92,
+ 0x3c, 0xbd, 0x86, 0x05, 0xe9, 0xcd, 0x9f, 0x26,
+ 0x6f, 0x08, 0xf0, 0x43, 0x87, 0x5a, 0x50, 0x60,
+ 0x8d, 0xd8, 0xa2, 0x34, 0x97, 0x03, 0xfb, 0xf8,
+ 0x64, 0x7c, 0x8e, 0x07, 0xe6, 0x3f, 0xf4, 0xda,
+ 0xd3, 0xc8, 0x64, 0x44, 0x29, 0x51, 0xf6, 0x98,
+ 0x79, 0x40, 0xf2, 0x6b, 0x30, 0x39, 0x11, 0x12,
+ 0xe5, 0xff, 0x23, 0x66, 0x41, 0x54, 0x12, 0x89,
+ 0xaf, 0xc2, 0x74, 0xdc, 0xbe, 0x37, 0x6c, 0x59,
+ 0x9f, 0xb6, 0x8f, 0x6d, 0x51, 0x2a, 0x91, 0x4d,
+ 0x77, 0x70, 0xe2, 0xf3, 0x1d, 0x6e, 0x67, 0xb0,
+ 0xff, 0xbd, 0x9b, 0xce, 0x20, 0xa2, 0x6a, 0x5d,
+ 0x3d, 0x82, 0x49, 0x5f, 0x84, 0x89, 0xbe, 0xa0,
+ 0x9d, 0xbd, 0xa8, 0xfd, 0x5a, 0x1f, 0xf8, 0xab,
+ 0x43, 0x89, 0x0e, 0x68, 0xe3, 0x41, 0xed, 0xe7,
+ 0x72, 0xf9, 0x6b, 0x7d, 0x3d, 0x64, 0xa4, 0x78,
+ 0xb5, 0x8b, 0x2f, 0x05, 0x5a, 0x7e, 0x29, 0xd9,
+ 0x2f, 0x29, 0x8b, 0xd7, 0xfa, 0xff, 0x1c, 0x64,
+ 0x68, 0xa6, 0x12, 0x35, 0xc2, 0x06, 0x81, 0x8b,
+ 0xb5, 0xe0, 0x34, 0x2f, 0x4a, 0x84, 0x2d, 0xb0,
+ 0x9a, 0xc3, 0x0e, 0x8c, 0x54, 0x0d, 0x1a, 0x48,
+ 0x77, 0x70, 0x4e, 0xb7, 0xda, 0x5d, 0x40, 0x30,
+ 0xe2, 0x23, 0x0e, 0xaa, 0x1b, 0xa7, 0x3b, 0xf2,
+ 0x21, 0x60, 0x0f, 0xcc, 0x8f, 0x9b, 0xb9, 0x63,
+ 0x4f, 0x41, 0x8c, 0x57, 0x36, 0x13, 0x3a, 0xeb,
+ 0xaa, 0x9c, 0x74, 0xea, 0x0c, 0x41, 0xe5, 0xce,
+ 0xd6, 0x46, 0x69, 0xc9, 0xe9, 0xee, 0x07, 0xfd,
+ 0xfd, 0x86, 0x06, 0x35, 0xb4, 0x42, 0x22, 0x19,
+ 0xac, 0xbb, 0x2a, 0xa5, 0x7f, 0x56, 0x90, 0x18,
+ 0x66, 0x3a, 0x9a, 0x15, 0x59, 0x49, 0xc0, 0x80,
+ 0x1f, 0x3a, 0x41, 0x53, 0x0e, 0xeb, 0x96, 0xc6,
+ 0xdc, 0xa5, 0x73, 0x72, 0x19, 0x45, 0x67, 0x49,
+ 0xb4, 0x38, 0x0d, 0x4f, 0xcf, 0x93, 0xe4, 0xec,
+ 0x3c, 0xb1, 0xc8, 0xc9, 0x22, 0xb6, 0xee, 0xab,
+ 0x4d, 0x10, 0xcf, 0xfc, 0x14, 0x9e, 0x7e, 0x06,
+ 0x96, 0xb1, 0x1a, 0x52, 0xa4, 0x59, 0xc7, 0xbb,
+ 0x8c, 0x66, 0x8d, 0x45, 0xf3, 0xf2, 0x8b, 0x8b,
+ 0x90, 0xc6, 0xd9, 0xe2, 0xe2, 0x82, 0xc0, 0xe2,
+ 0x33, 0x38, 0x19, 0x00, 0xf6, 0xfa, 0x14, 0x02,
+ 0x73, 0x0e, 0x80, 0x9d, 0xc3, 0x22, 0x63, 0x52,
+ 0xee, 0x00, 0xb7, 0xac, 0x28, 0x50, 0xb3, 0xb6,
+ 0x4f, 0x68, 0x29, 0xa4, 0x34, 0x25, 0xe3, 0x76,
+ 0x75, 0xb4, 0xa5, 0xea, 0x8a, 0x72, 0x46, 0xe6,
+ 0x32, 0xd6, 0x19, 0xca, 0x03, 0x09, 0xe8, 0x8d,
+ 0x30, 0xfb, 0xac, 0x8a, 0xd6, 0xc6, 0x96, 0x32,
+ 0x8d, 0x04, 0x54, 0x2b, 0x82, 0x44, 0x96, 0x52,
+ 0x42, 0xa8, 0xdc, 0x52, 0x6d, 0xc0, 0x5a, 0x37,
+ 0xa1, 0xb5, 0xc7, 0x15, 0x81, 0x09, 0xea, 0x6a,
+ 0xf2, 0xa1, 0xea, 0x64, 0x2b, 0x1a, 0x52, 0xb0,
+ 0x1c, 0x5b, 0x31, 0xa3, 0xaa, 0x3d, 0xa2, 0x21,
+ 0xa7, 0x10, 0x72, 0x96, 0xb5, 0x4a, 0x0f, 0x71,
+ 0x05, 0x7d, 0x1c, 0x2e, 0x20, 0xbf, 0x81, 0xec,
+ 0xe0, 0x67, 0x53, 0x5f, 0x55, 0x66, 0x9d, 0xa0,
+ 0xac, 0x30, 0x9d, 0x8a, 0x56, 0xd3, 0xda, 0xeb,
+ 0xf7, 0xc9, 0x00, 0xf9, 0x93, 0xef, 0x1a, 0x1b,
+ 0x01, 0xbb, 0x8e, 0xc2, 0x37, 0x3e, 0x91, 0x54,
+ 0xce, 0x07, 0x03, 0xaa, 0x73, 0x09, 0xb1, 0xa1,
+ 0xe3, 0x96, 0xb6, 0xad, 0x71, 0xcb, 0x36, 0x45,
+ 0xf2, 0x3f, 0x04, 0x83, 0x08, 0x03, 0x4c, 0x2d,
+ 0xb2, 0x07, 0xc1, 0x65, 0x57, 0x30, 0x53, 0x7e,
+ 0x43, 0xf6, 0x36, 0x68, 0xfd, 0x86, 0x54, 0x23,
+ 0x7b, 0xe0, 0x6a, 0x53, 0x03, 0x6d, 0x4a, 0xa8,
+ 0x14, 0xd9, 0x12, 0x75, 0xae, 0xf6, 0x2d, 0xdb,
+ 0xb6, 0x8d, 0xb9, 0x9c, 0xcf, 0x0b, 0xd1, 0x96,
+ 0x5d, 0x1a, 0x66, 0xaa, 0x9a, 0x57, 0xac, 0x49,
+ 0xd5, 0xd6, 0xbf, 0x4e, 0x0a, 0x79, 0xf2, 0x17,
+ 0x75, 0x60, 0x27, 0xe5, 0x3c, 0x89, 0xcf, 0x4f,
+ 0x8f, 0xb8, 0x30, 0x59, 0xe7, 0x9c, 0x58, 0xe9,
+ 0xc5, 0xf2, 0x7c, 0xb9, 0xb8, 0x48, 0x92, 0xd3,
+ 0xc7, 0xe3, 0x62, 0x28, 0x97, 0x70, 0xdb, 0xc8,
+ 0xa7, 0xe6, 0x3b, 0x88, 0x69, 0x2d, 0x7d, 0x4f,
+ 0xf7, 0x65, 0x09, 0x97, 0x23, 0x73, 0x19, 0x26,
+ 0x8e, 0xf9, 0x26, 0x21, 0x2e, 0xbd, 0xfc, 0x55,
+ 0x72, 0x1b, 0x8d, 0xd3, 0xae, 0x5a, 0x13, 0x82,
+ 0xbb, 0x7e, 0x8e, 0x6d, 0x9f, 0x20, 0xa3, 0x1b,
+ 0x99, 0x7b, 0x12, 0x53, 0xca, 0x79, 0xc0, 0xec,
+ 0xde, 0xf4, 0x54, 0x4c, 0x67, 0xa3, 0x68, 0x41,
+ 0x8c, 0xd2, 0xd3, 0x28, 0x9a, 0x7a, 0xca, 0xfa,
+ 0xbe, 0xb3, 0xbb, 0xb5, 0x2f, 0x64, 0x18, 0xfd,
+ 0x67, 0x29, 0x9f, 0x04, 0x75, 0xec, 0x1b, 0x39,
+ 0x1e, 0x3b, 0xd8, 0xfb, 0x5d, 0xc8, 0xd5, 0x5b,
+ 0xcd, 0x8a, 0x1b, 0x25, 0x29, 0xd5, 0xd7, 0x90,
+ 0x49, 0xfa, 0xea, 0xb1, 0x9f, 0x1d, 0xcb, 0xd1,
+ 0x7f, 0x17, 0x55, 0xb8, 0x25, 0xa3, 0xb1, 0x5b,
+ 0xf8, 0x51, 0x98, 0xcc, 0x3e, 0x3b, 0xdc, 0x1d,
+ 0x3e, 0xa4, 0xbd, 0xfe, 0xe4, 0x4f, 0x3f, 0x7d,
+ 0x66, 0xee, 0x27, 0xd9, 0x3f, 0xea, 0xbf, 0xca,
+ 0xde, 0xfd, 0x71, 0x77, 0x7f, 0x7b, 0xff, 0xc3,
+ 0x9f, 0xab, 0x9f, 0x7f, 0x7d, 0xff, 0xdb, 0xdd,
+ 0xcd, 0xef, 0xef, 0xee, 0x0f, 0x79, 0xe6, 0x7c,
+ 0xea, 0x15, 0xfd, 0x97, 0xda, 0xa7, 0xc9, 0xbf,
+ 0xfe, 0xd0, 0xd7, 0x60
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/line.cpp b/src/mbgl/shaders/line.cpp
index a4df33d9b6..5dfce93da4 100644
--- a/src/mbgl/shaders/line.cpp
+++ b/src/mbgl/shaders/line.cpp
@@ -1,240 +1,276 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/line.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* line::name = "line";
-const char* line::vertexSource = R"MBGL_SHADER(
-
-
-// the distance over which the line edge fades out.
-// Retina devices need a smaller distance to avoid aliasing.
-#define ANTIALIASING 1.0 / DEVICE_PIXEL_RATIO / 2.0
-
-// floor(127 / 2) == 63.0
-// the maximum allowed miter limit is 2.0 at the moment. the extrude normal is
-// stored in a byte (-128..127). we scale regular normals up to length 63, but
-// there are also "special" normals that have a bigger length (of up to 126 in
-// this case).
-// #define scale 63.0
-#define scale 0.015873016
-
-attribute vec4 a_pos_normal;
-attribute vec4 a_data;
-
-uniform mat4 u_matrix;
-uniform mediump float u_ratio;
-uniform vec2 u_gl_units_to_pixels;
-
-varying vec2 v_normal;
-varying vec2 v_width2;
-varying float v_gamma_scale;
-varying highp float v_linesofar;
-
-
-#ifndef HAS_UNIFORM_u_color
-uniform lowp float a_color_t;
-attribute highp vec4 a_color;
-varying highp vec4 color;
-#else
-uniform highp vec4 u_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_blur
-uniform lowp float a_blur_t;
-attribute lowp vec2 a_blur;
-varying lowp float blur;
-#else
-uniform lowp float u_blur;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-uniform lowp float a_opacity_t;
-attribute lowp vec2 a_opacity;
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_gapwidth
-uniform lowp float a_gapwidth_t;
-attribute mediump vec2 a_gapwidth;
-#else
-uniform mediump float u_gapwidth;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_offset
-uniform lowp float a_offset_t;
-attribute lowp vec2 a_offset;
-#else
-uniform lowp float u_offset;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_width
-uniform lowp float a_width_t;
-attribute mediump vec2 a_width;
-#else
-uniform mediump float u_width;
-#endif
-
-
-void main() {
-
-#ifndef HAS_UNIFORM_u_color
- color = unpack_mix_vec4(a_color, a_color_t);
-#else
- highp vec4 color = u_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_blur
- blur = unpack_mix_vec2(a_blur, a_blur_t);
-#else
- lowp float blur = u_blur;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
- opacity = unpack_mix_vec2(a_opacity, a_opacity_t);
-#else
- lowp float opacity = u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_gapwidth
- mediump float gapwidth = unpack_mix_vec2(a_gapwidth, a_gapwidth_t);
-#else
- mediump float gapwidth = u_gapwidth;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_offset
- lowp float offset = unpack_mix_vec2(a_offset, a_offset_t);
-#else
- lowp float offset = u_offset;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_width
- mediump float width = unpack_mix_vec2(a_width, a_width_t);
-#else
- mediump float width = u_width;
-#endif
-
-
- vec2 a_extrude = a_data.xy - 128.0;
- float a_direction = mod(a_data.z, 4.0) - 1.0;
-
- v_linesofar = (floor(a_data.z / 4.0) + a_data.w * 64.0) * 2.0;
-
- vec2 pos = a_pos_normal.xy;
-
- // x is 1 if it's a round cap, 0 otherwise
- // y is 1 if the normal points up, and -1 if it points down
- mediump vec2 normal = a_pos_normal.zw;
- v_normal = normal;
-
- // these transformations used to be applied in the JS and native code bases.
- // moved them into the shader for clarity and simplicity.
- gapwidth = gapwidth / 2.0;
- float halfwidth = width / 2.0;
- offset = -1.0 * offset;
-
- float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0);
- float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + (halfwidth == 0.0 ? 0.0 : ANTIALIASING);
-
- // Scale the extrusion vector down to a normal and then up by the line width
- // of this vertex.
- mediump vec2 dist = outset * a_extrude * scale;
-
- // Calculate the offset when drawing a line that is to the side of the actual line.
- // We do this by creating a vector that points towards the extrude, but rotate
- // it when we're drawing round end points (a_direction = -1 or 1) since their
- // extrude vector points in another direction.
- mediump float u = 0.5 * a_direction;
- mediump float t = 1.0 - abs(u);
- mediump vec2 offset2 = offset * a_extrude * scale * normal.y * mat2(t, -u, u, t);
-
- vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0);
- gl_Position = u_matrix * vec4(pos + offset2 / u_ratio, 0.0, 1.0) + projected_extrude;
-
- // calculate how much the perspective view squishes or stretches the extrude
- float extrude_length_without_perspective = length(dist);
- float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels);
- v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;
-
- v_width2 = vec2(outset, inset);
-}
-
-)MBGL_SHADER";
-const char* line::fragmentSource = R"MBGL_SHADER(
-
-#ifndef HAS_UNIFORM_u_color
-varying highp vec4 color;
-#else
-uniform highp vec4 u_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_blur
-varying lowp float blur;
-#else
-uniform lowp float u_blur;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-varying vec2 v_width2;
-varying vec2 v_normal;
-varying float v_gamma_scale;
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_color
- highp vec4 color = u_color;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_blur
- lowp float blur = u_blur;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_opacity
- lowp float opacity = u_opacity;
-#endif
-
-
- // Calculate the distance of the pixel from the line in pixels.
- float dist = length(v_normal) * v_width2.s;
-
- // Calculate the antialiasing fade factor. This is either when fading in
- // the line in case of an offset line (v_width2.t) or when fading out
- // (v_width2.s)
- float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;
- float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);
-
- gl_FragColor = color * (alpha * opacity);
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* line::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x8d, 0x57, 0x6d, 0x93, 0xd3, 0x36,
+ 0x10, 0xfe, 0x9e, 0x5f, 0xb1, 0xc3, 0x7d, 0x20,
+ 0x39, 0x72, 0xce, 0x0b, 0xc7, 0xc1, 0x90, 0xb9,
+ 0x76, 0x6e, 0x28, 0x6d, 0xd3, 0xa1, 0xc0, 0x70,
+ 0xf4, 0xe5, 0x9b, 0x47, 0xb1, 0x95, 0x58, 0xad,
+ 0x6d, 0xb9, 0x96, 0x1c, 0x27, 0x74, 0xfa, 0xdf,
+ 0xbb, 0xab, 0x17, 0xdb, 0x49, 0x9c, 0x00, 0x03,
+ 0x13, 0xa3, 0x7d, 0x7b, 0xb4, 0xda, 0x95, 0x9e,
+ 0x1d, 0x0c, 0x26, 0x13, 0xd0, 0x09, 0x87, 0x58,
+ 0x28, 0xcd, 0xf2, 0x88, 0x83, 0xdc, 0xf2, 0x12,
+ 0xea, 0x44, 0x44, 0x89, 0x59, 0x4f, 0x45, 0xce,
+ 0x81, 0xc7, 0x1b, 0x0e, 0x6b, 0x16, 0x73, 0x05,
+ 0xb2, 0xd2, 0x01, 0xd9, 0x7c, 0xe2, 0x5a, 0xe4,
+ 0x0c, 0x62, 0xbe, 0x15, 0x11, 0x2e, 0xe7, 0x9c,
+ 0xc7, 0xc0, 0x40, 0x65, 0x2c, 0x4d, 0xd1, 0xbe,
+ 0xf1, 0xa6, 0x25, 0xb0, 0xad, 0x14, 0x28, 0x4b,
+ 0x05, 0x53, 0x22, 0xdf, 0x04, 0x83, 0xab, 0x98,
+ 0xaf, 0xc9, 0xe9, 0xc3, 0xfb, 0xcf, 0xcb, 0x87,
+ 0x77, 0xcb, 0x87, 0xc7, 0xe5, 0xfb, 0x9f, 0x60,
+ 0x16, 0x4c, 0x61, 0x02, 0x3f, 0xbc, 0xfd, 0x7d,
+ 0xf9, 0xe6, 0x6d, 0xf8, 0x71, 0xf9, 0xe7, 0xdb,
+ 0x77, 0xe1, 0xa7, 0x87, 0xcf, 0xcb, 0x0f, 0xb8,
+ 0x38, 0x0f, 0xa6, 0x03, 0x8a, 0xb8, 0x4e, 0xa5,
+ 0x2c, 0x87, 0xb3, 0xf9, 0x4b, 0x5a, 0x1b, 0xc1,
+ 0xfd, 0x3d, 0xdc, 0x3d, 0x47, 0x91, 0xc3, 0x9f,
+ 0xb1, 0x9d, 0xc8, 0xaa, 0x0c, 0xe3, 0xa4, 0xb2,
+ 0x46, 0x2c, 0x99, 0xd0, 0x88, 0x23, 0x15, 0xf8,
+ 0x0b, 0x42, 0x91, 0x13, 0x60, 0xda, 0x6a, 0xca,
+ 0x8c, 0xe7, 0x3a, 0x30, 0xdf, 0x7c, 0xa7, 0xcb,
+ 0x2a, 0xe6, 0x90, 0xcb, 0x12, 0x91, 0xa3, 0x22,
+ 0xb9, 0x53, 0x5a, 0x96, 0xe8, 0x41, 0xe4, 0xb8,
+ 0xa1, 0xd5, 0x5e, 0x73, 0x18, 0xde, 0xcc, 0xe6,
+ 0xaf, 0x82, 0x00, 0x43, 0x8f, 0x02, 0xa8, 0x39,
+ 0xa8, 0x88, 0xa5, 0x1c, 0x4a, 0xbe, 0xa9, 0x52,
+ 0x56, 0x3a, 0x5b, 0x05, 0x55, 0x41, 0xbb, 0x4d,
+ 0x79, 0xbe, 0xd1, 0x09, 0x42, 0x1b, 0xc3, 0xaa,
+ 0xd2, 0x0e, 0x5d, 0xc9, 0x81, 0xd1, 0xbf, 0x54,
+ 0x49, 0x78, 0xa2, 0x0a, 0x1e, 0x09, 0x96, 0x3e,
+ 0x69, 0x0c, 0x75, 0x82, 0xc8, 0x12, 0xb6, 0xe5,
+ 0x14, 0x4f, 0x6c, 0x36, 0x84, 0xdb, 0x7a, 0x19,
+ 0xca, 0xb5, 0x73, 0x3b, 0x9b, 0xdf, 0x21, 0x20,
+ 0xeb, 0x0e, 0xb7, 0x13, 0x31, 0xc5, 0x47, 0xe6,
+ 0x1c, 0x7c, 0x36, 0x2d, 0x26, 0x93, 0x91, 0xc3,
+ 0xa5, 0x69, 0x30, 0x9d, 0xbd, 0x78, 0xf5, 0xf2,
+ 0xf9, 0x74, 0x76, 0x37, 0x18, 0x30, 0xad, 0x4b,
+ 0x81, 0xb8, 0x38, 0x6c, 0x79, 0x74, 0x0b, 0x2c,
+ 0x2c, 0xa4, 0x0a, 0x2d, 0x8e, 0xc5, 0xa9, 0x30,
+ 0x66, 0x9a, 0x2d, 0x06, 0x83, 0x2a, 0x17, 0x6b,
+ 0x54, 0xc1, 0x14, 0xeb, 0x5b, 0xa8, 0x42, 0xfc,
+ 0x29, 0xc5, 0x6e, 0xd1, 0x2e, 0xf3, 0x58, 0x54,
+ 0x59, 0x41, 0xe7, 0x83, 0xfb, 0xa8, 0xc2, 0x92,
+ 0x69, 0x21, 0x5b, 0x31, 0xfa, 0x9a, 0xe3, 0xea,
+ 0x26, 0x0d, 0x71, 0x45, 0xab, 0x50, 0xcb, 0xb0,
+ 0x10, 0x3b, 0x9e, 0x2a, 0xf4, 0xbc, 0x65, 0xe5,
+ 0x1e, 0x6b, 0xc2, 0xea, 0x6c, 0x1b, 0x20, 0x47,
+ 0xcb, 0xb5, 0x88, 0x75, 0x32, 0x6f, 0x97, 0x6d,
+ 0xa0, 0x6d, 0xb8, 0x61, 0x59, 0xc6, 0x42, 0xb3,
+ 0xcb, 0x56, 0x98, 0x88, 0x4d, 0x52, 0x34, 0x2a,
+ 0x54, 0xbd, 0x4a, 0xae, 0x59, 0x89, 0xc1, 0x06,
+ 0x57, 0x62, 0x9d, 0x63, 0x6a, 0xe0, 0xe7, 0x87,
+ 0xc7, 0xf0, 0xb7, 0xf7, 0xcb, 0x1f, 0x3f, 0x7c,
+ 0xfa, 0x35, 0xac, 0xc2, 0x48, 0xa6, 0xb2, 0x6c,
+ 0xd0, 0x62, 0xf1, 0x78, 0x6b, 0x66, 0x45, 0xa1,
+ 0xee, 0x66, 0xc6, 0xba, 0x77, 0xf9, 0x31, 0xf2,
+ 0xe3, 0xd0, 0x46, 0xe6, 0x24, 0x57, 0xb8, 0x4d,
+ 0xde, 0xf8, 0xee, 0xc8, 0xab, 0xb0, 0xd1, 0xc8,
+ 0x63, 0xb1, 0x3e, 0x0b, 0x6e, 0x95, 0x56, 0x67,
+ 0xb0, 0x91, 0xe4, 0x10, 0x9a, 0x11, 0x9b, 0x94,
+ 0x59, 0x69, 0x0b, 0xac, 0x63, 0x68, 0x05, 0x87,
+ 0xb8, 0x3a, 0xe2, 0x2a, 0xf4, 0x0a, 0x17, 0x61,
+ 0xc9, 0x82, 0x45, 0x42, 0xef, 0xfb, 0x91, 0x39,
+ 0xe1, 0x79, 0x70, 0x4e, 0xa1, 0x17, 0x5f, 0x23,
+ 0xbb, 0x00, 0xb1, 0xa3, 0x73, 0x11, 0xe5, 0x86,
+ 0x15, 0xa6, 0x74, 0xfa, 0x61, 0x7a, 0xe9, 0x21,
+ 0x4e, 0x5f, 0xcc, 0x0e, 0xaa, 0x57, 0x3a, 0xc6,
+ 0x73, 0x5c, 0xf3, 0x5d, 0xbd, 0xcb, 0x99, 0x5b,
+ 0xaf, 0x15, 0xd7, 0x67, 0x12, 0x67, 0x64, 0x17,
+ 0xf2, 0x66, 0xe4, 0x97, 0x53, 0xd3, 0xa8, 0x5c,
+ 0x44, 0x71, 0x21, 0x2d, 0x5f, 0xcf, 0xc9, 0x37,
+ 0x25, 0xe4, 0x38, 0x1b, 0xe6, 0x0d, 0xc8, 0x98,
+ 0xc8, 0x87, 0x23, 0xf8, 0x77, 0x00, 0xf8, 0xe7,
+ 0x62, 0x3b, 0x92, 0x82, 0xf9, 0x82, 0x7b, 0xa8,
+ 0x72, 0x3c, 0xef, 0xbf, 0xc3, 0x4c, 0xec, 0x42,
+ 0xea, 0x9d, 0xa1, 0xeb, 0xbb, 0x71, 0xdb, 0xa0,
+ 0x23, 0x8f, 0x86, 0xcc, 0x8e, 0xbb, 0x90, 0x3c,
+ 0x1c, 0x77, 0xdb, 0x85, 0xf8, 0xa6, 0xe3, 0x48,
+ 0x4e, 0x1f, 0x27, 0xd1, 0xe7, 0x43, 0xdb, 0x5b,
+ 0xe3, 0xa6, 0x03, 0x0f, 0x62, 0x1f, 0x35, 0x9a,
+ 0x09, 0x7d, 0xd8, 0x50, 0x17, 0x22, 0xfb, 0xa6,
+ 0x22, 0x15, 0xf7, 0xdd, 0x1b, 0xdf, 0xc9, 0xc6,
+ 0xdd, 0x56, 0x3b, 0x87, 0xa2, 0xe3, 0xe7, 0xb4,
+ 0x6d, 0x2e, 0x60, 0x69, 0x5a, 0x87, 0x74, 0x0e,
+ 0xcf, 0xd6, 0x8b, 0x7a, 0xb1, 0x79, 0xe1, 0xf8,
+ 0xa0, 0xc1, 0x0e, 0xd0, 0x9d, 0xf7, 0xd6, 0xd3,
+ 0x45, 0x97, 0xd2, 0x65, 0x3b, 0xe9, 0x78, 0xc3,
+ 0x66, 0xb5, 0x3f, 0x6f, 0x46, 0x34, 0xee, 0x34,
+ 0xda, 0xd9, 0xac, 0x35, 0x4e, 0x4e, 0x1a, 0xea,
+ 0x02, 0xa0, 0x73, 0x09, 0x3b, 0x9f, 0xad, 0x26,
+ 0x55, 0x5f, 0xcf, 0x53, 0x9b, 0xa4, 0xe3, 0xce,
+ 0x22, 0x5d, 0xd7, 0x99, 0x9e, 0xcd, 0xdc, 0xbb,
+ 0xb7, 0x3b, 0xd8, 0xed, 0xe1, 0x06, 0x88, 0xbb,
+ 0x4c, 0x17, 0x46, 0xcf, 0x37, 0x79, 0x2c, 0x4a,
+ 0x1e, 0xe1, 0x2b, 0x9d, 0xa3, 0x6a, 0x26, 0xe3,
+ 0xa1, 0x53, 0xff, 0x32, 0x86, 0xdb, 0x60, 0x3a,
+ 0x22, 0x1b, 0xb2, 0xb0, 0xae, 0xdb, 0x37, 0x14,
+ 0x95, 0x87, 0x96, 0x84, 0x79, 0x7d, 0x64, 0x62,
+ 0xc6, 0xe0, 0x99, 0x0f, 0x58, 0xc3, 0x35, 0xdc,
+ 0x99, 0xa5, 0x6b, 0xa2, 0x5c, 0x8b, 0x0e, 0x3c,
+ 0x64, 0x1a, 0x06, 0x58, 0xcb, 0x38, 0x10, 0x9e,
+ 0x53, 0x40, 0x1e, 0xb3, 0x23, 0x96, 0x36, 0x03,
+ 0xb1, 0x06, 0xa1, 0x9f, 0x2a, 0x64, 0x42, 0xa5,
+ 0xac, 0xf2, 0x18, 0x89, 0x4e, 0x31, 0x86, 0x29,
+ 0x48, 0x22, 0x51, 0xb5, 0x70, 0xa9, 0x41, 0xf5,
+ 0x7d, 0xa3, 0x4e, 0x34, 0xce, 0xd1, 0xb7, 0x42,
+ 0x8a, 0x5c, 0x13, 0x11, 0xc3, 0x9c, 0xa2, 0xed,
+ 0x8d, 0x73, 0xe7, 0xd7, 0x63, 0x59, 0xe7, 0x07,
+ 0xa9, 0x35, 0xb8, 0x9c, 0xed, 0x11, 0xb4, 0x2f,
+ 0xf5, 0xc2, 0x6d, 0xbf, 0x91, 0x7b, 0x76, 0xe2,
+ 0x21, 0x60, 0x60, 0x85, 0x04, 0xb7, 0x64, 0xb9,
+ 0xa2, 0x2b, 0x90, 0x58, 0x4f, 0x8e, 0xc1, 0x15,
+ 0x52, 0x47, 0x24, 0x6c, 0x2b, 0x64, 0x73, 0x45,
+ 0x91, 0x0a, 0x4b, 0x24, 0x09, 0xe4, 0x2f, 0x8f,
+ 0x06, 0x55, 0x8e, 0x8a, 0x48, 0xf5, 0x22, 0x89,
+ 0x07, 0xb5, 0x42, 0x1a, 0xa7, 0x02, 0xef, 0x30,
+ 0x43, 0xea, 0x1d, 0x93, 0x6a, 0x86, 0x26, 0xe8,
+ 0x82, 0x8c, 0x54, 0x82, 0xac, 0xbb, 0x04, 0x0c,
+ 0x00, 0x11, 0x92, 0x4d, 0xea, 0x65, 0x72, 0xa2,
+ 0x44, 0x86, 0xbe, 0xa9, 0x9d, 0xad, 0x75, 0xa7,
+ 0x8d, 0x9a, 0xcf, 0x89, 0x3d, 0x81, 0xf6, 0xdc,
+ 0x13, 0x96, 0xae, 0xbd, 0xd6, 0x89, 0x4a, 0x53,
+ 0xf3, 0x37, 0x44, 0xc5, 0xaf, 0xc1, 0x17, 0x7e,
+ 0xc7, 0x5e, 0xe4, 0x56, 0xa3, 0x89, 0xf0, 0x0c,
+ 0x86, 0xcd, 0xf7, 0x77, 0x44, 0x34, 0xe1, 0xfb,
+ 0x43, 0x56, 0xff, 0x9a, 0x16, 0x47, 0x5d, 0x0c,
+ 0x38, 0x3e, 0x9c, 0x38, 0x69, 0x71, 0x5d, 0xf7,
+ 0x38, 0x24, 0xe6, 0xfe, 0x9a, 0x0a, 0x92, 0xca,
+ 0x6c, 0xd8, 0xd9, 0xc3, 0xbd, 0x53, 0x98, 0x1a,
+ 0x85, 0x6e, 0xdc, 0x51, 0x7b, 0x48, 0x8f, 0x86,
+ 0x03, 0x37, 0x54, 0x5f, 0x51, 0xcd, 0xe3, 0xb1,
+ 0x23, 0xc3, 0x37, 0xe5, 0x60, 0xe6, 0x13, 0x5f,
+ 0x02, 0x94, 0x58, 0xd4, 0xcc, 0x89, 0x72, 0xaf,
+ 0xf6, 0xed, 0xf4, 0xd3, 0x36, 0x36, 0x3a, 0x94,
+ 0x6b, 0xcb, 0xc0, 0x71, 0x4a, 0xd2, 0x7c, 0x17,
+ 0x9c, 0xd6, 0x13, 0x8d, 0x3e, 0xb8, 0x3f, 0xb7,
+ 0xd1, 0xeb, 0x4e, 0x5b, 0x5e, 0x83, 0xe3, 0xaa,
+ 0xde, 0xd7, 0x1b, 0x96, 0x46, 0x38, 0x42, 0x68,
+ 0x0b, 0xd0, 0x9d, 0x40, 0x4d, 0x08, 0xe2, 0x92,
+ 0xd5, 0xc4, 0x8c, 0x98, 0x45, 0x60, 0x26, 0x04,
+ 0x0c, 0xea, 0x8b, 0x42, 0xc4, 0xdc, 0x02, 0xc1,
+ 0x22, 0x8b, 0x74, 0x85, 0xd8, 0x49, 0xad, 0x29,
+ 0xa4, 0x3f, 0x70, 0x9c, 0x93, 0x16, 0x26, 0xee,
+ 0x23, 0x2a, 0x39, 0x96, 0x9c, 0x71, 0xe6, 0x76,
+ 0x6e, 0xdc, 0xb9, 0xa6, 0xd0, 0xb2, 0x66, 0x65,
+ 0xac, 0xba, 0xd3, 0x90, 0x99, 0x5c, 0xb0, 0xff,
+ 0x34, 0x22, 0xf3, 0x2e, 0x85, 0x03, 0x56, 0xf3,
+ 0xa7, 0x38, 0xc8, 0x78, 0x78, 0xb6, 0x47, 0xf1,
+ 0x26, 0xf2, 0xde, 0x86, 0x87, 0x77, 0x0b, 0x76,
+ 0x20, 0x86, 0x9b, 0x8d, 0x10, 0xb1, 0x19, 0x06,
+ 0x13, 0x2e, 0x4a, 0xef, 0xd1, 0x67, 0xc5, 0x61,
+ 0x72, 0x0e, 0x68, 0xe8, 0xca, 0x4d, 0xb7, 0x43,
+ 0xe3, 0x28, 0xe8, 0xb9, 0x0f, 0x2b, 0xa0, 0xe3,
+ 0x7f, 0x61, 0xf2, 0xdb, 0x28, 0x2e, 0x7a, 0x14,
+ 0xe9, 0x2c, 0xa8, 0xa2, 0x6f, 0x80, 0xad, 0xd4,
+ 0xb0, 0x1a, 0x2d, 0x4e, 0x4f, 0xcc, 0x26, 0x7e,
+ 0x4e, 0x87, 0x66, 0x8f, 0xa0, 0xe7, 0xd0, 0xf0,
+ 0xd7, 0xdd, 0x0c, 0x7b, 0xfc, 0xc4, 0x66, 0x9f,
+ 0x0f, 0xf1, 0x29, 0xb9, 0xa9, 0xc6, 0x80, 0x7f,
+ 0xf5, 0xa8, 0xbd, 0xe8, 0x6e, 0xa1, 0x28, 0xe5,
+ 0x5f, 0x88, 0x87, 0xc7, 0x9d, 0xfb, 0xd8, 0x4f,
+ 0x4d, 0x68, 0x6b, 0x38, 0x8c, 0x29, 0x92, 0x89,
+ 0x1f, 0x96, 0xc6, 0x54, 0xc3, 0xe3, 0x4e, 0xaf,
+ 0xe0, 0xb0, 0xf4, 0x51, 0x2a, 0xe1, 0xb2, 0x78,
+ 0x6c, 0x4c, 0x37, 0xe9, 0xb3, 0x06, 0xf5, 0xb1,
+ 0x17, 0xd7, 0x29, 0x27, 0x28, 0xda, 0xb2, 0x8b,
+ 0x9a, 0xb2, 0x4b, 0x64, 0x0d, 0x59, 0xe5, 0x26,
+ 0xfd, 0x82, 0x97, 0x34, 0x9a, 0x9a, 0xdb, 0x69,
+ 0x2b, 0x78, 0x0d, 0xea, 0x9f, 0x4a, 0xa8, 0x84,
+ 0x66, 0xfe, 0x12, 0x67, 0xe2, 0x92, 0xeb, 0x88,
+ 0xfe, 0xd3, 0x29, 0x94, 0x4e, 0x5f, 0xbb, 0x95,
+ 0xd0, 0x0e, 0xae, 0xf8, 0x48, 0xe9, 0x04, 0x3b,
+ 0x20, 0xec, 0xfa, 0xbc, 0x77, 0x53, 0xad, 0xd9,
+ 0xfc, 0xc1, 0xa5, 0xd0, 0x63, 0xdc, 0x6f, 0x79,
+ 0xb2, 0x29, 0x7a, 0xe1, 0x26, 0xdd, 0x74, 0x99,
+ 0x17, 0xa8, 0x6f, 0xda, 0x1c, 0xf9, 0xfb, 0xbc,
+ 0x33, 0x35, 0xa2, 0xe3, 0x6f, 0xc0, 0x3d, 0xf9,
+ 0x1a, 0xbe, 0xe6, 0xa5, 0xb4, 0x83, 0x2a, 0x7a,
+ 0x35, 0xef, 0xbb, 0xbd, 0x01, 0xc6, 0xf6, 0xda,
+ 0xc4, 0xf0, 0xff, 0x0d, 0xfe, 0x07, 0x19, 0xfc,
+ 0xc0, 0x02
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* line::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x85, 0x92, 0x51, 0x6f, 0x9b, 0x30,
+ 0x10, 0xc7, 0xdf, 0xf9, 0x14, 0x27, 0xf5, 0x05,
+ 0xb2, 0x8c, 0x64, 0xd1, 0xde, 0xa2, 0x3d, 0x44,
+ 0x29, 0xd5, 0x90, 0xb6, 0xa6, 0xa2, 0x59, 0xb7,
+ 0x37, 0xeb, 0x06, 0x06, 0x2c, 0x19, 0x1b, 0x61,
+ 0x93, 0xac, 0x9a, 0xf6, 0xdd, 0x67, 0x1b, 0x68,
+ 0x08, 0x4d, 0xda, 0x28, 0x42, 0xf2, 0xdd, 0xf9,
+ 0xf7, 0xbf, 0xfb, 0xfb, 0xbc, 0x1b, 0x96, 0x8b,
+ 0x8c, 0xe6, 0xf0, 0x75, 0xf3, 0x48, 0x7e, 0xdc,
+ 0xc7, 0x77, 0xbb, 0xe4, 0x3b, 0x69, 0x49, 0x2a,
+ 0xb9, 0x6c, 0xbc, 0x03, 0x36, 0xcf, 0x4c, 0x14,
+ 0x50, 0xb2, 0xa2, 0xac, 0xe1, 0x40, 0xd3, 0xcf,
+ 0xe0, 0x12, 0x6b, 0xef, 0x86, 0x72, 0x45, 0xbd,
+ 0x56, 0xb0, 0x5c, 0x36, 0xd5, 0x38, 0xdf, 0x5f,
+ 0xb5, 0x15, 0x22, 0x63, 0xb9, 0xe7, 0x79, 0x97,
+ 0x05, 0x7e, 0xf3, 0xf6, 0xc4, 0xe7, 0xf2, 0x58,
+ 0x43, 0xce, 0x25, 0x6a, 0xb0, 0xf1, 0x29, 0x7e,
+ 0x94, 0xee, 0x2e, 0xbe, 0x4b, 0x97, 0x35, 0xa6,
+ 0x4c, 0x3f, 0x5f, 0x12, 0xe8, 0x53, 0x6f, 0x6a,
+ 0x8c, 0x6a, 0x7a, 0x99, 0x01, 0x64, 0x66, 0x5c,
+ 0xc1, 0x81, 0x1c, 0x59, 0xa6, 0xcb, 0xd5, 0x7a,
+ 0x1a, 0x16, 0x86, 0x84, 0xfc, 0x14, 0xee, 0x78,
+ 0x07, 0x52, 0x60, 0x55, 0x21, 0x51, 0x29, 0x72,
+ 0xba, 0x36, 0x2c, 0xc9, 0x32, 0xa8, 0x90, 0x09,
+ 0x3f, 0x80, 0xbf, 0x1e, 0x98, 0x9f, 0x9d, 0xe2,
+ 0xda, 0x1b, 0xd8, 0xfc, 0xd4, 0x7f, 0xf8, 0xf2,
+ 0xda, 0xe7, 0xeb, 0x1c, 0x67, 0xb5, 0x4d, 0x4f,
+ 0x6c, 0x76, 0x94, 0x73, 0x3b, 0xaf, 0x43, 0x06,
+ 0x47, 0x27, 0x9c, 0x3e, 0xec, 0x50, 0xaf, 0x5d,
+ 0xb3, 0xc5, 0x8b, 0x05, 0x6c, 0x91, 0xa7, 0x2d,
+ 0x47, 0x4d, 0x41, 0x97, 0x14, 0x32, 0xa6, 0x34,
+ 0x8a, 0x94, 0x82, 0xcc, 0xdd, 0xb9, 0x66, 0x7f,
+ 0x28, 0x87, 0xbc, 0x91, 0x95, 0x3b, 0x72, 0x26,
+ 0x28, 0x30, 0xd1, 0x85, 0x55, 0xe8, 0x18, 0x9d,
+ 0x96, 0xbd, 0x68, 0x84, 0x38, 0x15, 0x85, 0x2e,
+ 0xfd, 0xc1, 0xed, 0x00, 0x66, 0x2f, 0x0f, 0x12,
+ 0xaa, 0xf5, 0x15, 0x51, 0x14, 0x9a, 0x21, 0x67,
+ 0xa8, 0xdc, 0xb3, 0x60, 0x46, 0xcd, 0x27, 0xd5,
+ 0xb2, 0x09, 0x61, 0x5f, 0x32, 0x05, 0xe6, 0x4f,
+ 0x99, 0xa9, 0x6b, 0xe0, 0x58, 0x52, 0x61, 0x0b,
+ 0x6c, 0x1d, 0x13, 0x03, 0x6c, 0xdc, 0x58, 0x8a,
+ 0xca, 0xf5, 0x8e, 0xc2, 0x7c, 0x73, 0x45, 0x75,
+ 0x97, 0xf1, 0x5f, 0x9a, 0xd0, 0x01, 0xc8, 0x73,
+ 0x90, 0x6c, 0xf5, 0x40, 0x3a, 0x95, 0xa9, 0x60,
+ 0x34, 0x9b, 0x7d, 0x86, 0x95, 0x19, 0xce, 0x77,
+ 0x0f, 0xf3, 0x01, 0x3e, 0x85, 0x4b, 0x58, 0xc0,
+ 0x6d, 0xf4, 0x14, 0x6f, 0x23, 0xf2, 0x10, 0xff,
+ 0x8a, 0xbe, 0x91, 0x64, 0xb3, 0x8f, 0x77, 0xdd,
+ 0xb4, 0x67, 0xfb, 0x74, 0x82, 0x20, 0xaf, 0x4b,
+ 0x34, 0x90, 0x94, 0x63, 0x55, 0xfb, 0x95, 0x59,
+ 0x30, 0x67, 0xd9, 0xc7, 0x71, 0x6f, 0xe6, 0xe4,
+ 0xb4, 0x82, 0xf9, 0xc8, 0x35, 0x13, 0xb4, 0x95,
+ 0x81, 0x91, 0x74, 0xc9, 0x39, 0x2c, 0xc3, 0xe5,
+ 0xdc, 0x36, 0x11, 0xf4, 0x86, 0x16, 0x9c, 0xdc,
+ 0x35, 0x58, 0x6c, 0xfb, 0xed, 0xeb, 0xb6, 0x70,
+ 0x06, 0x7e, 0x27, 0x39, 0x1b, 0xf6, 0xc0, 0x96,
+ 0xf7, 0xeb, 0xb3, 0x7b, 0x8a, 0x92, 0xdb, 0x64,
+ 0xf3, 0x93, 0xc4, 0xf7, 0x8f, 0x0f, 0xd1, 0x76,
+ 0xbf, 0x4b, 0x2e, 0x81, 0xec, 0x4e, 0xfb, 0x9d,
+ 0x4e, 0xbf, 0x35, 0xff, 0xbc, 0xff, 0x74, 0x55,
+ 0x77, 0xc9
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/line_pattern.cpp b/src/mbgl/shaders/line_pattern.cpp
index 374fc0a995..775285e05d 100644
--- a/src/mbgl/shaders/line_pattern.cpp
+++ b/src/mbgl/shaders/line_pattern.cpp
@@ -1,241 +1,325 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/line_pattern.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* line_pattern::name = "line_pattern";
-const char* line_pattern::vertexSource = R"MBGL_SHADER(
-// floor(127 / 2) == 63.0
-// the maximum allowed miter limit is 2.0 at the moment. the extrude normal is
-// stored in a byte (-128..127). we scale regular normals up to length 63, but
-// there are also "special" normals that have a bigger length (of up to 126 in
-// this case).
-// #define scale 63.0
-#define scale 0.015873016
-
-// We scale the distance before adding it to the buffers so that we can store
-// long distances for long segments. Use this value to unscale the distance.
-#define LINE_DISTANCE_SCALE 2.0
-
-// the distance over which the line edge fades out.
-// Retina devices need a smaller distance to avoid aliasing.
-#define ANTIALIASING 1.0 / DEVICE_PIXEL_RATIO / 2.0
-
-attribute vec4 a_pos_normal;
-attribute vec4 a_data;
-
-uniform mat4 u_matrix;
-uniform mediump float u_ratio;
-uniform vec2 u_gl_units_to_pixels;
-
-varying vec2 v_normal;
-varying vec2 v_width2;
-varying float v_linesofar;
-varying float v_gamma_scale;
-
-
-#ifndef HAS_UNIFORM_u_blur
-uniform lowp float a_blur_t;
-attribute lowp vec2 a_blur;
-varying lowp float blur;
-#else
-uniform lowp float u_blur;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-uniform lowp float a_opacity_t;
-attribute lowp vec2 a_opacity;
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_offset
-uniform lowp float a_offset_t;
-attribute lowp vec2 a_offset;
-#else
-uniform lowp float u_offset;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_gapwidth
-uniform lowp float a_gapwidth_t;
-attribute mediump vec2 a_gapwidth;
-#else
-uniform mediump float u_gapwidth;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_width
-uniform lowp float a_width_t;
-attribute mediump vec2 a_width;
-#else
-uniform mediump float u_width;
-#endif
-
-
-void main() {
-
-#ifndef HAS_UNIFORM_u_blur
- blur = unpack_mix_vec2(a_blur, a_blur_t);
-#else
- lowp float blur = u_blur;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
- opacity = unpack_mix_vec2(a_opacity, a_opacity_t);
-#else
- lowp float opacity = u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_offset
- lowp float offset = unpack_mix_vec2(a_offset, a_offset_t);
-#else
- lowp float offset = u_offset;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_gapwidth
- mediump float gapwidth = unpack_mix_vec2(a_gapwidth, a_gapwidth_t);
-#else
- mediump float gapwidth = u_gapwidth;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_width
- mediump float width = unpack_mix_vec2(a_width, a_width_t);
-#else
- mediump float width = u_width;
-#endif
-
-
- 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 = a_pos_normal.xy;
-
- // x is 1 if it's a round cap, 0 otherwise
- // y is 1 if the normal points up, and -1 if it points down
- mediump vec2 normal = a_pos_normal.zw;
- v_normal = normal;
-
- // these transformations used to be applied in the JS and native code bases.
- // moved them into the shader for clarity and simplicity.
- gapwidth = gapwidth / 2.0;
- float halfwidth = width / 2.0;
- offset = -1.0 * offset;
-
- float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0);
- float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + (halfwidth == 0.0 ? 0.0 : ANTIALIASING);
-
- // Scale the extrusion vector down to a normal and then up by the line width
- // of this vertex.
- mediump vec2 dist = outset * a_extrude * scale;
-
- // Calculate the offset when drawing a line that is to the side of the actual line.
- // We do this by creating a vector that points towards the extrude, but rotate
- // it when we're drawing round end points (a_direction = -1 or 1) since their
- // extrude vector points in another direction.
- mediump float u = 0.5 * a_direction;
- mediump float t = 1.0 - abs(u);
- mediump vec2 offset2 = offset * a_extrude * scale * normal.y * mat2(t, -u, u, t);
-
- vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0);
- gl_Position = u_matrix * vec4(pos + offset2 / u_ratio, 0.0, 1.0) + projected_extrude;
-
- // calculate how much the perspective view squishes or stretches the extrude
- float extrude_length_without_perspective = length(dist);
- float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels);
- v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;
-
- v_linesofar = a_linesofar;
- v_width2 = vec2(outset, inset);
-}
-
-)MBGL_SHADER";
-const char* line_pattern::fragmentSource = R"MBGL_SHADER(
-uniform vec2 u_pattern_size_a;
-uniform vec2 u_pattern_size_b;
-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_fade;
-
-uniform sampler2D u_image;
-
-varying vec2 v_normal;
-varying vec2 v_width2;
-varying float v_linesofar;
-varying float v_gamma_scale;
-
-
-#ifndef HAS_UNIFORM_u_blur
-varying lowp float blur;
-#else
-uniform lowp float u_blur;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_blur
- lowp float blur = u_blur;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_opacity
- lowp float opacity = u_opacity;
-#endif
-
-
- // Calculate the distance of the pixel from the line in pixels.
- float dist = length(v_normal) * v_width2.s;
-
- // Calculate the antialiasing fade factor. This is either when fading in
- // the line in case of an offset line (v_width2.t) or when fading out
- // (v_width2.s)
- float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;
- float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);
-
- float x_a = mod(v_linesofar / u_pattern_size_a.x, 1.0);
- float x_b = mod(v_linesofar / u_pattern_size_b.x, 1.0);
-
- // v_normal.y is 0 at the midpoint of the line, -1 at the lower edge, 1 at the upper edge
- // we clamp the line width outset to be between 0 and half the pattern height plus padding (2.0)
- // to ensure we don't sample outside the designated symbol on the sprite sheet.
- // 0.5 is added to shift the component to be bounded between 0 and 1 for interpolation of
- // the texture coordinate
- float y_a = 0.5 + (v_normal.y * clamp(v_width2.s, 0.0, (u_pattern_size_a.y + 2.0) / 2.0) / u_pattern_size_a.y);
- float y_b = 0.5 + (v_normal.y * clamp(v_width2.s, 0.0, (u_pattern_size_b.y + 2.0) / 2.0) / u_pattern_size_b.y);
- vec2 pos_a = mix(u_pattern_tl_a / u_texsize, u_pattern_br_a / u_texsize, vec2(x_a, y_a));
- vec2 pos_b = mix(u_pattern_tl_b / u_texsize, u_pattern_br_b / u_texsize, vec2(x_b, y_b));
-
- vec4 color = mix(texture2D(u_image, pos_a), texture2D(u_image, pos_b), u_fade);
-
- gl_FragColor = color * alpha * opacity;
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* line_pattern::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x8d, 0x57, 0x5b, 0x6f, 0xdb, 0x36,
+ 0x14, 0x7e, 0xf7, 0xaf, 0x38, 0x68, 0x1e, 0x6a,
+ 0xa7, 0x8e, 0x7c, 0x69, 0x9a, 0x16, 0x35, 0xb2,
+ 0x21, 0x68, 0xb3, 0xcd, 0x43, 0x96, 0x16, 0x4d,
+ 0xbb, 0xed, 0x4d, 0xa0, 0x25, 0xca, 0xe6, 0x26,
+ 0x89, 0x9a, 0x48, 0x59, 0x76, 0x87, 0xfd, 0xf7,
+ 0x9d, 0xc3, 0x8b, 0x2c, 0xdb, 0xb2, 0xdb, 0x22,
+ 0x45, 0x14, 0x9e, 0x0b, 0x3f, 0x9e, 0x0b, 0xf9,
+ 0x9d, 0xd1, 0x08, 0x92, 0x54, 0xca, 0xb2, 0x3f,
+ 0x99, 0xbe, 0x86, 0x11, 0x4c, 0x07, 0x70, 0x7b,
+ 0x0b, 0x37, 0x2f, 0x83, 0x71, 0x6f, 0x34, 0x02,
+ 0xbd, 0xe2, 0x90, 0xb1, 0x8d, 0xc8, 0xaa, 0x0c,
+ 0x58, 0x9a, 0xca, 0x9a, 0xc7, 0x90, 0x09, 0xcd,
+ 0x4b, 0x48, 0x05, 0xfe, 0x06, 0xa1, 0x60, 0x1a,
+ 0x8c, 0x81, 0x69, 0xab, 0x29, 0x33, 0x9e, 0xeb,
+ 0xc0, 0x7c, 0xf3, 0x8d, 0x2e, 0xab, 0x98, 0x43,
+ 0x2e, 0xcb, 0x8c, 0xa5, 0xa8, 0x48, 0xee, 0x94,
+ 0x96, 0x25, 0x7a, 0x10, 0x39, 0x30, 0x58, 0x6c,
+ 0x35, 0x87, 0xfe, 0xd5, 0x64, 0xfa, 0x26, 0x08,
+ 0x70, 0xeb, 0x41, 0x00, 0x35, 0x07, 0x15, 0xb1,
+ 0x94, 0x43, 0xc9, 0x97, 0x55, 0xca, 0x4a, 0x67,
+ 0xab, 0xa0, 0x2a, 0x40, 0x4b, 0x48, 0x79, 0xbe,
+ 0xd4, 0x2b, 0x84, 0x36, 0x84, 0x45, 0xa5, 0x1d,
+ 0xba, 0x92, 0x03, 0xa3, 0xff, 0xa9, 0x92, 0xf0,
+ 0x4c, 0x15, 0x3c, 0x12, 0x2c, 0x7d, 0xd6, 0x18,
+ 0xea, 0x15, 0x22, 0x5b, 0xb1, 0x35, 0xa7, 0xfd,
+ 0xc4, 0x72, 0x49, 0xb8, 0xad, 0x97, 0xbe, 0x4c,
+ 0x9c, 0xdb, 0xc9, 0xf4, 0x06, 0x01, 0x59, 0x77,
+ 0x78, 0x9c, 0x88, 0x29, 0x3e, 0x08, 0xe8, 0xcf,
+ 0x8b, 0x98, 0x27, 0x22, 0xf7, 0x98, 0x4c, 0x44,
+ 0xf6, 0x97, 0xc6, 0xc1, 0x78, 0xf2, 0xea, 0xcd,
+ 0xeb, 0x97, 0xe3, 0xc9, 0x4d, 0x8f, 0x0c, 0xfe,
+ 0xf0, 0x02, 0x3a, 0x7f, 0x2c, 0x94, 0x66, 0x79,
+ 0xc4, 0x61, 0xc1, 0x13, 0x49, 0x08, 0xe3, 0x58,
+ 0xe4, 0x4b, 0xc0, 0x98, 0xe1, 0x9e, 0xa4, 0xb0,
+ 0xa8, 0x92, 0x84, 0x97, 0x0a, 0x94, 0xb4, 0x30,
+ 0xf1, 0xf4, 0x11, 0xcb, 0x6d, 0x88, 0xc8, 0x5b,
+ 0x2a, 0x51, 0xdd, 0x7b, 0x51, 0x80, 0x4e, 0xec,
+ 0x92, 0xe2, 0x4b, 0x8a, 0xb2, 0x0a, 0xe0, 0x8b,
+ 0xe2, 0x16, 0xf3, 0x9a, 0xa5, 0x15, 0x27, 0xbf,
+ 0x55, 0x7e, 0x0c, 0x20, 0x68, 0x50, 0x3f, 0xcc,
+ 0x1f, 0xef, 0xc3, 0xf7, 0xf3, 0xa7, 0xcf, 0x77,
+ 0x8f, 0xef, 0xee, 0xc3, 0xa7, 0x77, 0x77, 0x0f,
+ 0xf7, 0x94, 0xbd, 0x9e, 0x4f, 0x74, 0x03, 0x59,
+ 0xae, 0x31, 0x50, 0xf5, 0x4a, 0x44, 0x2b, 0xb3,
+ 0x9e, 0x92, 0x31, 0x8f, 0x97, 0x1c, 0x12, 0x16,
+ 0x23, 0x14, 0x59, 0x69, 0x13, 0xa0, 0x4f, 0x5c,
+ 0x8b, 0x9c, 0x41, 0xcc, 0xd7, 0x82, 0x10, 0xe6,
+ 0x1c, 0x53, 0xcb, 0x40, 0x61, 0xe4, 0x53, 0xb4,
+ 0x6f, 0xbc, 0x21, 0x2e, 0xb6, 0x96, 0x02, 0x65,
+ 0xa9, 0x60, 0x0a, 0x83, 0xb0, 0x43, 0x74, 0xf7,
+ 0xf8, 0x79, 0x7e, 0xf7, 0x30, 0xbf, 0x7b, 0x9a,
+ 0x3f, 0xfe, 0x0c, 0x13, 0x2c, 0xa4, 0x11, 0xbc,
+ 0xbf, 0xff, 0x7d, 0x8e, 0xe8, 0x3e, 0xce, 0xff,
+ 0xbc, 0x7f, 0x08, 0x3f, 0xdd, 0x7d, 0x9e, 0x7f,
+ 0xa0, 0xa2, 0x24, 0x94, 0x4c, 0xeb, 0x52, 0x60,
+ 0xe6, 0x39, 0xac, 0x79, 0x74, 0x0d, 0x2c, 0x2c,
+ 0xa4, 0x0a, 0x6d, 0xa6, 0x67, 0xc7, 0xc2, 0x98,
+ 0x69, 0x36, 0xeb, 0xf5, 0xaa, 0x5c, 0x60, 0xe4,
+ 0x32, 0x2c, 0x62, 0x7d, 0x0d, 0x55, 0x88, 0xbf,
+ 0x4a, 0xb1, 0x99, 0xed, 0x96, 0x79, 0x2c, 0xaa,
+ 0xac, 0xa0, 0x0e, 0xc0, 0x14, 0x54, 0x61, 0xc9,
+ 0xb4, 0x90, 0x3b, 0x31, 0xfa, 0x9a, 0xe2, 0xea,
+ 0x32, 0x0d, 0x71, 0x45, 0xab, 0x50, 0xcb, 0xb0,
+ 0x10, 0x1b, 0x9e, 0x2a, 0xf4, 0xbc, 0x66, 0xe5,
+ 0x96, 0x32, 0x6a, 0x74, 0xd6, 0x0d, 0x90, 0x83,
+ 0xe5, 0x5a, 0xc4, 0x7a, 0x35, 0xdd, 0x2d, 0xdb,
+ 0x8d, 0xd6, 0x21, 0xc5, 0x54, 0xc9, 0x84, 0x95,
+ 0xc7, 0xa2, 0x25, 0xcb, 0x32, 0x16, 0x9a, 0x44,
+ 0xe2, 0x36, 0xbd, 0x0b, 0x91, 0xe4, 0x18, 0x2e,
+ 0xf8, 0xe5, 0xee, 0x29, 0xfc, 0xf2, 0x38, 0xff,
+ 0xe9, 0xc3, 0xa7, 0xdf, 0xc2, 0x2a, 0x5c, 0xa4,
+ 0x55, 0xd9, 0xc0, 0xc4, 0xbe, 0xf4, 0x47, 0x60,
+ 0x46, 0x12, 0xea, 0x76, 0x44, 0x8c, 0xd8, 0xe0,
+ 0xb1, 0xd2, 0xdd, 0x96, 0x2d, 0x43, 0x2b, 0xb8,
+ 0xc0, 0xb3, 0xf1, 0x2e, 0xbf, 0x55, 0xe8, 0x15,
+ 0xf2, 0x58, 0x24, 0x27, 0x61, 0xc9, 0x82, 0x45,
+ 0x42, 0x6f, 0xbb, 0x91, 0x39, 0xe1, 0x69, 0x70,
+ 0x4e, 0xa1, 0x13, 0x5f, 0x23, 0x3b, 0x03, 0xb1,
+ 0xa5, 0x73, 0x1e, 0x65, 0x92, 0x28, 0xae, 0x4f,
+ 0x80, 0x34, 0xb2, 0x33, 0x18, 0x8d, 0xfc, 0x3c,
+ 0x8c, 0x46, 0xe5, 0x2c, 0x8a, 0x25, 0x2b, 0x4c,
+ 0x75, 0x74, 0xe3, 0xf0, 0xd2, 0x7d, 0x24, 0xbe,
+ 0x5e, 0x1d, 0x18, 0xaf, 0x74, 0x08, 0xe7, 0xb0,
+ 0xac, 0xdb, 0x7a, 0x67, 0x31, 0x9d, 0x01, 0xf4,
+ 0x6d, 0x34, 0xdf, 0x05, 0xe5, 0x10, 0x87, 0xb9,
+ 0x19, 0x32, 0x26, 0xf2, 0xfe, 0x00, 0xfe, 0xed,
+ 0x01, 0xfe, 0x3b, 0x57, 0xf1, 0x24, 0xa7, 0x0f,
+ 0xb8, 0xc5, 0xbb, 0x0e, 0xb3, 0xfd, 0x77, 0x98,
+ 0x89, 0x4d, 0x48, 0xfb, 0xf7, 0x6d, 0x6d, 0x0f,
+ 0x9b, 0x0e, 0x18, 0x78, 0x24, 0x64, 0x73, 0x50,
+ 0xe8, 0x64, 0x7e, 0x50, 0xd0, 0x67, 0x76, 0xf6,
+ 0x45, 0x4d, 0x2a, 0xee, 0xbb, 0x73, 0x7f, 0x27,
+ 0x1b, 0xb6, 0x4b, 0xfd, 0x14, 0x8a, 0x96, 0x9f,
+ 0xe3, 0xb2, 0x3d, 0x87, 0xc5, 0x96, 0xee, 0xa1,
+ 0x37, 0xb3, 0xda, 0x0d, 0xca, 0x88, 0x86, 0xad,
+ 0xca, 0x3e, 0x09, 0xa9, 0x71, 0x72, 0x54, 0xc1,
+ 0x67, 0x00, 0x35, 0x55, 0x4c, 0x3a, 0xfb, 0xc9,
+ 0xf6, 0xa2, 0x4e, 0x5c, 0x5e, 0x38, 0xdc, 0xab,
+ 0xf5, 0x3d, 0x6c, 0xa7, 0xbd, 0x75, 0x14, 0xf4,
+ 0x19, 0x88, 0xa7, 0xf0, 0x9d, 0x06, 0xd7, 0x20,
+ 0xfb, 0x36, 0xac, 0x1d, 0xa6, 0xc3, 0xca, 0x26,
+ 0x5d, 0xd7, 0x19, 0x9e, 0x0c, 0xdd, 0xba, 0x87,
+ 0x29, 0xd8, 0x6c, 0xe1, 0x0a, 0x88, 0xfa, 0x8c,
+ 0x67, 0x46, 0xcf, 0x37, 0x59, 0x2c, 0x4a, 0x1e,
+ 0xe1, 0x13, 0x94, 0xa3, 0x6a, 0x26, 0xe3, 0xbe,
+ 0x53, 0xff, 0x3a, 0x84, 0xeb, 0x60, 0x3c, 0x20,
+ 0x9b, 0x43, 0x8b, 0xe6, 0x21, 0x41, 0x8b, 0xbe,
+ 0x25, 0x72, 0xde, 0x08, 0x1f, 0x4e, 0x63, 0xf5,
+ 0xc2, 0xef, 0x5a, 0xc3, 0x25, 0xdc, 0x98, 0xa5,
+ 0xcb, 0x2e, 0x32, 0x30, 0x6b, 0x61, 0xc6, 0xb7,
+ 0xd5, 0xa0, 0xdd, 0xbd, 0xb1, 0x88, 0xd9, 0x29,
+ 0xe0, 0xd3, 0xbf, 0x21, 0xe6, 0x37, 0x01, 0x91,
+ 0x20, 0xa1, 0x79, 0xae, 0xf0, 0xd5, 0x2f, 0x65,
+ 0x95, 0xc7, 0x48, 0x60, 0x8a, 0x21, 0x8c, 0x41,
+ 0x12, 0x31, 0xab, 0x85, 0x8b, 0x17, 0xaa, 0x6f,
+ 0x1b, 0x75, 0xe2, 0x13, 0x8e, 0x12, 0x16, 0x52,
+ 0x20, 0x8d, 0x41, 0x16, 0x86, 0x81, 0x46, 0xdb,
+ 0x2b, 0xe7, 0xce, 0xaf, 0xc7, 0xb2, 0xce, 0xf7,
+ 0xe2, 0x6d, 0x70, 0x39, 0xdb, 0x03, 0x68, 0x5f,
+ 0x6b, 0x1b, 0x14, 0xff, 0x0c, 0xa3, 0xdc, 0xbf,
+ 0xc7, 0x1e, 0x02, 0x6e, 0x4c, 0x74, 0xa9, 0x64,
+ 0xb9, 0xa2, 0x7b, 0x89, 0xde, 0xf9, 0x1c, 0x37,
+ 0x57, 0xc8, 0x59, 0x90, 0xa0, 0x2c, 0x90, 0xa0,
+ 0x15, 0x45, 0x2a, 0x2c, 0x39, 0x25, 0x90, 0xbf,
+ 0x3e, 0x19, 0x54, 0x39, 0x2a, 0x22, 0x7d, 0x8c,
+ 0x24, 0x66, 0x6f, 0x81, 0xd4, 0x50, 0x05, 0xde,
+ 0x61, 0x86, 0x2c, 0x29, 0x26, 0xd5, 0x0c, 0x4d,
+ 0x1c, 0xa7, 0x53, 0x2b, 0x24, 0x48, 0xa5, 0xe1,
+ 0x6a, 0x11, 0x12, 0x58, 0x6a, 0x70, 0x72, 0xa2,
+ 0x44, 0x86, 0xbe, 0xa9, 0xc7, 0xad, 0x75, 0xab,
+ 0x94, 0x9b, 0x4f, 0x43, 0x72, 0xda, 0xa9, 0x5d,
+ 0xb1, 0x34, 0xf1, 0x5a, 0x47, 0x2a, 0x4d, 0xaf,
+ 0x5e, 0x11, 0x6b, 0xba, 0x04, 0xdf, 0xb0, 0x2d,
+ 0x7b, 0x91, 0x5b, 0x8d, 0x66, 0x87, 0x17, 0xd0,
+ 0x6f, 0xbe, 0x7f, 0x20, 0xf2, 0x0a, 0x3f, 0xee,
+ 0x13, 0xb0, 0xb7, 0xb4, 0x38, 0x68, 0x63, 0x40,
+ 0xa6, 0x77, 0xe4, 0x64, 0x87, 0xeb, 0xb2, 0xc3,
+ 0x21, 0x4d, 0x03, 0x6f, 0xa9, 0x4a, 0xa9, 0xec,
+ 0xfa, 0xad, 0x33, 0xdc, 0x3a, 0x85, 0xb1, 0x51,
+ 0x68, 0xef, 0x3b, 0xd8, 0x25, 0xe9, 0xa9, 0x61,
+ 0xaf, 0xa6, 0x63, 0x14, 0x35, 0x02, 0xa6, 0x1d,
+ 0x29, 0xb1, 0x29, 0x07, 0x43, 0x25, 0x7d, 0x09,
+ 0x50, 0x60, 0x51, 0x33, 0x27, 0x1a, 0xbf, 0xd8,
+ 0xee, 0x88, 0xea, 0xae, 0xdb, 0xd1, 0xa1, 0x4c,
+ 0x1c, 0x43, 0xe6, 0xa5, 0xe6, 0x9b, 0xe0, 0xb8,
+ 0x9e, 0x88, 0xa5, 0xe2, 0xf9, 0xdc, 0x41, 0x2f,
+ 0x5b, 0xbd, 0x7a, 0x09, 0x9e, 0x82, 0x39, 0x5f,
+ 0xef, 0x58, 0x1a, 0xe1, 0x58, 0xa2, 0x2d, 0x40,
+ 0x97, 0x81, 0x9a, 0x10, 0xc4, 0x25, 0xab, 0x89,
+ 0xae, 0x30, 0x8b, 0xc0, 0xd0, 0x79, 0xdc, 0xd4,
+ 0x17, 0x85, 0x88, 0xb9, 0x05, 0x82, 0x45, 0x16,
+ 0xe9, 0x0a, 0xb1, 0x93, 0x5a, 0x53, 0x48, 0x38,
+ 0x36, 0xc4, 0xd2, 0xc2, 0xc4, 0x73, 0x44, 0x25,
+ 0xc7, 0x92, 0x33, 0xce, 0xdc, 0xc9, 0x8d, 0x3b,
+ 0xd7, 0x14, 0x5a, 0xd6, 0xac, 0x8c, 0x55, 0x7b,
+ 0xc2, 0x32, 0xd3, 0x10, 0xf6, 0x9f, 0x46, 0x64,
+ 0xde, 0xa5, 0x70, 0xc0, 0x6a, 0xfe, 0x1c, 0x47,
+ 0x0f, 0x0f, 0xcf, 0xf6, 0x28, 0x5e, 0x4f, 0xde,
+ 0x5b, 0x7f, 0xff, 0xc2, 0xc1, 0x0e, 0xc4, 0xed,
+ 0x26, 0x03, 0x44, 0x6c, 0x78, 0xfb, 0x8a, 0x8b,
+ 0xd2, 0x7b, 0xf4, 0x51, 0x71, 0x98, 0x9c, 0x03,
+ 0x1a, 0xe4, 0x72, 0xd3, 0xed, 0xd0, 0x38, 0x0a,
+ 0x3a, 0x2e, 0xc9, 0x0a, 0x28, 0xfd, 0xaf, 0x4c,
+ 0x7c, 0x1b, 0xc5, 0x59, 0x87, 0x22, 0xe5, 0x82,
+ 0x2a, 0xfa, 0x0a, 0xd8, 0x42, 0xf5, 0xab, 0xc1,
+ 0xec, 0x38, 0x63, 0x36, 0xf0, 0x53, 0x4a, 0x9a,
+ 0x4d, 0x41, 0x47, 0xd2, 0xf0, 0xb7, 0xbb, 0x19,
+ 0xb6, 0xf8, 0x89, 0xcd, 0x3e, 0xed, 0xe3, 0x13,
+ 0x78, 0x55, 0x0d, 0x01, 0x7f, 0xf4, 0x60, 0x77,
+ 0xd1, 0x5d, 0x43, 0x51, 0xca, 0xbf, 0x10, 0x0f,
+ 0x8f, 0x5b, 0x97, 0xb4, 0x9f, 0x13, 0xd0, 0x96,
+ 0x74, 0xfa, 0xa6, 0x48, 0x46, 0x7e, 0x3c, 0x18,
+ 0x52, 0x0d, 0x0f, 0x5b, 0xbd, 0x82, 0xe3, 0xc1,
+ 0x47, 0xa9, 0x84, 0x8b, 0xe2, 0xa1, 0x31, 0xdd,
+ 0xa4, 0x2f, 0x1a, 0xd4, 0x87, 0x5e, 0x5c, 0xa7,
+ 0x1c, 0xa1, 0xd8, 0x95, 0x5d, 0xd4, 0x94, 0xdd,
+ 0x4a, 0xd6, 0x90, 0x55, 0x6e, 0x28, 0x2b, 0x70,
+ 0x76, 0x2c, 0x28, 0x90, 0x78, 0x3b, 0xad, 0x05,
+ 0xaf, 0x41, 0xfd, 0x53, 0x09, 0xb5, 0xa2, 0xf1,
+ 0xac, 0xc4, 0x21, 0xb2, 0xe4, 0x3a, 0xa2, 0x3f,
+ 0x5a, 0x85, 0xd2, 0xea, 0x6b, 0xb7, 0x12, 0xda,
+ 0x61, 0x18, 0x5f, 0x2e, 0xbd, 0xc2, 0x0e, 0x08,
+ 0xdb, 0x3e, 0x6f, 0xdd, 0xa4, 0x6c, 0x0e, 0xbf,
+ 0x77, 0x29, 0x74, 0x18, 0x77, 0x5b, 0x1e, 0x1d,
+ 0x8a, 0x9e, 0xbd, 0x51, 0x3b, 0x5c, 0xe6, 0x45,
+ 0xea, 0x9a, 0xaf, 0x06, 0xfe, 0x3e, 0x6f, 0x0d,
+ 0x43, 0xe8, 0xf8, 0x3b, 0x70, 0x8f, 0xbe, 0x85,
+ 0xcf, 0x27, 0x7f, 0xef, 0xe5, 0x64, 0xed, 0x81,
+ 0xcc, 0x8a, 0xed, 0xe4, 0x86, 0x32, 0xc3, 0x09,
+ 0xec, 0x05, 0x31, 0xb4, 0xb7, 0x2a, 0xa2, 0xfb,
+ 0xaf, 0xf7, 0x3f, 0x47, 0x21, 0xaf, 0x4b
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* line_pattern::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0xa5, 0x55, 0x5d, 0x6f, 0x9b, 0x30,
+ 0x14, 0x7d, 0xcf, 0xaf, 0xb8, 0xd2, 0x1e, 0x06,
+ 0x29, 0xa5, 0x69, 0xb4, 0x3d, 0x55, 0x7b, 0xa8,
+ 0xda, 0x54, 0x8b, 0xb4, 0x35, 0x55, 0xda, 0x75,
+ 0x7b, 0x43, 0x06, 0x0c, 0x58, 0x32, 0x36, 0xc2,
+ 0x26, 0x1f, 0x9b, 0xf6, 0xdf, 0x77, 0x6d, 0x0c,
+ 0x21, 0x49, 0x93, 0x4d, 0x5a, 0x84, 0x88, 0xb8,
+ 0x1f, 0xe7, 0xdc, 0xeb, 0x7b, 0x6c, 0x37, 0x82,
+ 0x65, 0xb2, 0x2e, 0x61, 0x45, 0x93, 0x29, 0x34,
+ 0x51, 0x45, 0xb4, 0xa6, 0xb5, 0x88, 0x14, 0xfb,
+ 0x49, 0x23, 0x72, 0x33, 0x6a, 0xce, 0xb8, 0xe3,
+ 0x93, 0x6e, 0xcd, 0xcf, 0xe4, 0xc6, 0xf5, 0x19,
+ 0x27, 0x66, 0xc6, 0xe7, 0x32, 0x8f, 0x9d, 0x9a,
+ 0x6e, 0x4c, 0x35, 0x3b, 0x7b, 0xc6, 0x25, 0xd1,
+ 0xe8, 0xc8, 0x48, 0x8a, 0xd6, 0xde, 0xac, 0x48,
+ 0x59, 0x71, 0x5a, 0x4f, 0xef, 0xd1, 0xc5, 0x4a,
+ 0x92, 0x1b, 0xdf, 0x8a, 0xd4, 0x5b, 0x26, 0xf2,
+ 0x16, 0x6a, 0x15, 0x09, 0x8c, 0x23, 0xfc, 0xe6,
+ 0xd0, 0xbc, 0x66, 0xa9, 0x2e, 0xa6, 0x3b, 0x73,
+ 0x4b, 0xb0, 0x8a, 0x38, 0x13, 0x54, 0xc9, 0x8c,
+ 0xd4, 0xc7, 0xae, 0x9c, 0x94, 0x25, 0x89, 0x54,
+ 0x42, 0xb8, 0xa1, 0x19, 0xbd, 0x63, 0x99, 0x48,
+ 0x69, 0x06, 0x9f, 0x6f, 0x9f, 0xa3, 0x6f, 0x8f,
+ 0xf3, 0x87, 0xc5, 0xf2, 0x6b, 0xd4, 0x44, 0x31,
+ 0x6f, 0xea, 0x3e, 0x93, 0xcb, 0x75, 0xe5, 0xd2,
+ 0x8d, 0xfd, 0x66, 0xf4, 0x8e, 0x72, 0x45, 0xfb,
+ 0xea, 0x07, 0xee, 0x36, 0xd1, 0x04, 0x88, 0x94,
+ 0x65, 0x27, 0xd1, 0x65, 0x45, 0x12, 0xa6, 0xb7,
+ 0x6f, 0x11, 0x38, 0xd7, 0x59, 0x8e, 0x41, 0x8c,
+ 0xa3, 0x59, 0x49, 0x96, 0x42, 0x49, 0x98, 0xf0,
+ 0x7c, 0xf8, 0x35, 0x02, 0xfc, 0x19, 0xe6, 0x13,
+ 0x6d, 0x19, 0xf7, 0x41, 0x4b, 0xf0, 0xe9, 0xa8,
+ 0xf4, 0xd3, 0x20, 0x5d, 0xf5, 0x07, 0x38, 0xce,
+ 0x6c, 0xa1, 0x8e, 0x2b, 0x34, 0xc1, 0x57, 0x57,
+ 0x70, 0x47, 0x78, 0xd2, 0x70, 0xa2, 0x29, 0xe8,
+ 0x82, 0x42, 0xca, 0x94, 0x26, 0x22, 0xa1, 0x20,
+ 0x33, 0xfb, 0x5d, 0xb1, 0x0d, 0xe5, 0x90, 0xd5,
+ 0xb2, 0xb4, 0x9f, 0x66, 0x88, 0xc0, 0x44, 0x6b,
+ 0x56, 0xa1, 0xc5, 0x68, 0xb9, 0x4c, 0x22, 0x12,
+ 0x71, 0x2a, 0x72, 0x5d, 0x78, 0x9d, 0x3a, 0x7c,
+ 0x18, 0xf7, 0x92, 0x08, 0xd5, 0xcd, 0x09, 0x52,
+ 0x22, 0x34, 0x23, 0x9c, 0x11, 0x65, 0x45, 0x81,
+ 0x42, 0xc4, 0x57, 0xa2, 0x65, 0x1d, 0xc2, 0x4b,
+ 0xc1, 0x14, 0xe0, 0x43, 0x19, 0xc6, 0xd5, 0xb0,
+ 0x2e, 0xa8, 0x30, 0x01, 0x26, 0x8e, 0x89, 0x0e,
+ 0x6c, 0x58, 0x58, 0x42, 0x94, 0xad, 0x9d, 0x08,
+ 0x7c, 0x67, 0x8a, 0xea, 0xd6, 0xe3, 0xf5, 0x45,
+ 0x68, 0x1f, 0xe4, 0x3e, 0x90, 0x6c, 0x74, 0x87,
+ 0xb4, 0x0b, 0x53, 0xfe, 0xa0, 0x37, 0x33, 0x86,
+ 0x29, 0x36, 0xe7, 0xd9, 0xc1, 0x5c, 0xc0, 0x75,
+ 0x38, 0x81, 0x2b, 0xb8, 0x9f, 0xbd, 0xce, 0xef,
+ 0x66, 0xd1, 0xd3, 0xfc, 0xc7, 0xec, 0x4b, 0xb4,
+ 0xbc, 0x7d, 0x99, 0x2f, 0xda, 0x6e, 0xf7, 0xd4,
+ 0xbc, 0x03, 0x21, 0xbc, 0x2a, 0x08, 0x82, 0x24,
+ 0x1c, 0xb7, 0x96, 0x57, 0xa2, 0x30, 0xec, 0x92,
+ 0x5d, 0x0e, 0x6b, 0xc3, 0x2f, 0xcb, 0xe5, 0x07,
+ 0x83, 0x55, 0x43, 0xa3, 0x89, 0xf4, 0x91, 0xd2,
+ 0x3a, 0x03, 0x98, 0x84, 0x93, 0xc0, 0x14, 0xe1,
+ 0xbb, 0x05, 0x6d, 0x09, 0x36, 0x91, 0x81, 0x2f,
+ 0x65, 0xea, 0x0d, 0x36, 0x1b, 0x26, 0x1d, 0x1e,
+ 0x53, 0xe1, 0xa6, 0x4b, 0x1e, 0xe6, 0xc6, 0xff,
+ 0x92, 0x1b, 0xef, 0x72, 0xbb, 0x25, 0xeb, 0x26,
+ 0x1d, 0x6e, 0xcd, 0x9c, 0x26, 0x80, 0x60, 0x66,
+ 0x1e, 0x25, 0x4b, 0x2b, 0xc9, 0x84, 0xee, 0x74,
+ 0x64, 0x40, 0x03, 0xb8, 0xbc, 0xee, 0xfc, 0xa8,
+ 0x52, 0x9c, 0x27, 0x4d, 0x73, 0xb4, 0xf6, 0xc6,
+ 0xa6, 0xaa, 0x9c, 0xb1, 0x43, 0x5f, 0xd3, 0x76,
+ 0xbd, 0x76, 0x33, 0xb6, 0xab, 0x62, 0x66, 0x66,
+ 0x66, 0xab, 0x25, 0xc4, 0x14, 0x1f, 0xbd, 0xa6,
+ 0x38, 0x4f, 0x24, 0x17, 0x29, 0x14, 0x84, 0x3b,
+ 0xe9, 0xb6, 0x95, 0x43, 0x41, 0x59, 0x5e, 0x68,
+ 0xa8, 0x78, 0xa3, 0xd0, 0x96, 0xda, 0x99, 0x7b,
+ 0x53, 0x6c, 0xa2, 0xd7, 0x8f, 0x04, 0x2a, 0x54,
+ 0x53, 0x53, 0x43, 0x97, 0x4a, 0xf1, 0x5e, 0xbb,
+ 0xe3, 0xcf, 0xd2, 0xb0, 0xd4, 0xed, 0x0c, 0xaa,
+ 0x58, 0x2e, 0x50, 0xb2, 0x29, 0xa8, 0x6d, 0x19,
+ 0x4b, 0x0e, 0x52, 0x58, 0x87, 0xaa, 0x6a, 0x86,
+ 0x42, 0x56, 0x05, 0xa5, 0x3a, 0xec, 0x30, 0x27,
+ 0xe1, 0x47, 0xb3, 0x1e, 0x48, 0x87, 0xf1, 0x48,
+ 0xa0, 0x0a, 0x96, 0xb5, 0x4d, 0x26, 0xb2, 0xac,
+ 0xa4, 0xa0, 0xa2, 0xaf, 0x5e, 0x36, 0xc2, 0x04,
+ 0xed, 0x77, 0x71, 0x0d, 0x78, 0xc8, 0xa0, 0xa0,
+ 0xb1, 0x83, 0x4a, 0xe2, 0x46, 0x61, 0xd2, 0x08,
+ 0x7a, 0xa8, 0x78, 0x3c, 0xc9, 0xb5, 0xa9, 0x39,
+ 0x91, 0xb2, 0xc6, 0x9e, 0xb0, 0xb0, 0xc1, 0x3c,
+ 0xb7, 0x56, 0x0b, 0xa6, 0x88, 0x0b, 0xf0, 0x06,
+ 0x23, 0x1a, 0x3b, 0xf9, 0xed, 0xd4, 0xe5, 0xd4,
+ 0xe4, 0x1d, 0xa9, 0x64, 0x8b, 0xa9, 0x66, 0x95,
+ 0x50, 0x05, 0xee, 0xef, 0x38, 0x64, 0x4f, 0x43,
+ 0x5b, 0xab, 0xa1, 0xff, 0xe0, 0x8c, 0xff, 0xce,
+ 0x19, 0xf7, 0x9c, 0xf6, 0xb6, 0xa9, 0xa4, 0x6a,
+ 0x45, 0xcf, 0x36, 0xde, 0xfe, 0x7d, 0x6a, 0x53,
+ 0xdd, 0x65, 0x17, 0x1c, 0x5c, 0xa7, 0xfb, 0x3e,
+ 0x03, 0xe4, 0xe1, 0xde, 0x09, 0xcc, 0xa2, 0xf9,
+ 0x87, 0xe8, 0xf1, 0x5b, 0xe8, 0xf1, 0x19, 0xf4,
+ 0xf8, 0x4d, 0xf4, 0xd8, 0xa0, 0xc7, 0x7e, 0xb7,
+ 0x6f, 0xd0, 0xfa, 0x01, 0x07, 0xc7, 0x65, 0xed,
+ 0xe0, 0xdd, 0x30, 0xa7, 0xf7, 0x9e, 0xbb, 0x6e,
+ 0x83, 0xb6, 0x37, 0x3c, 0x08, 0x4e, 0xb8, 0x62,
+ 0x3f, 0x70, 0xb7, 0x76, 0x07, 0x9a, 0xf3, 0xe8,
+ 0xa1, 0x26, 0xf9, 0x9d, 0x83, 0x6d, 0xe1, 0xc7,
+ 0xee, 0xdc, 0x19, 0xef, 0xae, 0xb1, 0xee, 0x0a,
+ 0x59, 0xbc, 0xce, 0x96, 0xf7, 0xcb, 0xdb, 0xef,
+ 0xd1, 0xfc, 0xf1, 0xf9, 0x69, 0x76, 0xf7, 0xb2,
+ 0x58, 0xbe, 0x05, 0x63, 0x4a, 0xf5, 0xda, 0x2d,
+ 0xef, 0x6e, 0x8e, 0xdf, 0xa3, 0x3f, 0xfb, 0x5c,
+ 0xf6, 0x33
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/line_sdf.cpp b/src/mbgl/shaders/line_sdf.cpp
index 9b6bf47301..bb50859c8d 100644
--- a/src/mbgl/shaders/line_sdf.cpp
+++ b/src/mbgl/shaders/line_sdf.cpp
@@ -1,302 +1,324 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/line_sdf.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* line_sdf::name = "line_sdf";
-const char* line_sdf::vertexSource = R"MBGL_SHADER(
-// floor(127 / 2) == 63.0
-// the maximum allowed miter limit is 2.0 at the moment. the extrude normal is
-// stored in a byte (-128..127). we scale regular normals up to length 63, but
-// there are also "special" normals that have a bigger length (of up to 126 in
-// this case).
-// #define scale 63.0
-#define scale 0.015873016
-
-// We scale the distance before adding it to the buffers so that we can store
-// long distances for long segments. Use this value to unscale the distance.
-#define LINE_DISTANCE_SCALE 2.0
-
-// the distance over which the line edge fades out.
-// Retina devices need a smaller distance to avoid aliasing.
-#define ANTIALIASING 1.0 / DEVICE_PIXEL_RATIO / 2.0
-
-attribute vec4 a_pos_normal;
-attribute vec4 a_data;
-
-uniform mat4 u_matrix;
-uniform mediump float u_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_gl_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;
-
-
-#ifndef HAS_UNIFORM_u_color
-uniform lowp float a_color_t;
-attribute highp vec4 a_color;
-varying highp vec4 color;
-#else
-uniform highp vec4 u_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_blur
-uniform lowp float a_blur_t;
-attribute lowp vec2 a_blur;
-varying lowp float blur;
-#else
-uniform lowp float u_blur;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-uniform lowp float a_opacity_t;
-attribute lowp vec2 a_opacity;
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_gapwidth
-uniform lowp float a_gapwidth_t;
-attribute mediump vec2 a_gapwidth;
-#else
-uniform mediump float u_gapwidth;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_offset
-uniform lowp float a_offset_t;
-attribute lowp vec2 a_offset;
-#else
-uniform lowp float u_offset;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_width
-uniform lowp float a_width_t;
-attribute mediump vec2 a_width;
-varying mediump float width;
-#else
-uniform mediump float u_width;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_floorwidth
-uniform lowp float a_floorwidth_t;
-attribute lowp vec2 a_floorwidth;
-varying lowp float floorwidth;
-#else
-uniform lowp float u_floorwidth;
-#endif
-
-
-void main() {
-
-#ifndef HAS_UNIFORM_u_color
- color = unpack_mix_vec4(a_color, a_color_t);
-#else
- highp vec4 color = u_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_blur
- blur = unpack_mix_vec2(a_blur, a_blur_t);
-#else
- lowp float blur = u_blur;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
- opacity = unpack_mix_vec2(a_opacity, a_opacity_t);
-#else
- lowp float opacity = u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_gapwidth
- mediump float gapwidth = unpack_mix_vec2(a_gapwidth, a_gapwidth_t);
-#else
- mediump float gapwidth = u_gapwidth;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_offset
- lowp float offset = unpack_mix_vec2(a_offset, a_offset_t);
-#else
- lowp float offset = u_offset;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_width
- width = unpack_mix_vec2(a_width, a_width_t);
-#else
- mediump float width = u_width;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_floorwidth
- floorwidth = unpack_mix_vec2(a_floorwidth, a_floorwidth_t);
-#else
- lowp float floorwidth = u_floorwidth;
-#endif
-
-
- 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 = a_pos_normal.xy;
-
- // x is 1 if it's a round cap, 0 otherwise
- // y is 1 if the normal points up, and -1 if it points down
- mediump vec2 normal = a_pos_normal.zw;
- v_normal = normal;
-
- // these transformations used to be applied in the JS and native code bases.
- // moved them into the shader for clarity and simplicity.
- gapwidth = gapwidth / 2.0;
- float halfwidth = width / 2.0;
- offset = -1.0 * offset;
-
- float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0);
- float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + (halfwidth == 0.0 ? 0.0 : ANTIALIASING);
-
- // Scale the extrusion vector down to a normal and then up by the line width
- // of this vertex.
- mediump vec2 dist =outset * a_extrude * scale;
-
- // Calculate the offset when drawing a line that is to the side of the actual line.
- // We do this by creating a vector that points towards the extrude, but rotate
- // it when we're drawing round end points (a_direction = -1 or 1) since their
- // extrude vector points in another direction.
- mediump float u = 0.5 * a_direction;
- mediump float t = 1.0 - abs(u);
- mediump vec2 offset2 = offset * a_extrude * scale * normal.y * mat2(t, -u, u, t);
-
- vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0);
- gl_Position = u_matrix * vec4(pos + offset2 / u_ratio, 0.0, 1.0) + projected_extrude;
-
- // calculate how much the perspective view squishes or stretches the extrude
- float extrude_length_without_perspective = length(dist);
- float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels);
- v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;
-
- v_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);
-}
-
-)MBGL_SHADER";
-const char* line_sdf::fragmentSource = R"MBGL_SHADER(
-
-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;
-
-
-#ifndef HAS_UNIFORM_u_color
-varying highp vec4 color;
-#else
-uniform highp vec4 u_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_blur
-varying lowp float blur;
-#else
-uniform lowp float u_blur;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_width
-varying mediump float width;
-#else
-uniform mediump float u_width;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_floorwidth
-varying lowp float floorwidth;
-#else
-uniform lowp float u_floorwidth;
-#endif
-
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_color
- highp vec4 color = u_color;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_blur
- lowp float blur = u_blur;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_opacity
- lowp float opacity = u_opacity;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_width
- mediump float width = u_width;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_floorwidth
- lowp float floorwidth = u_floorwidth;
-#endif
-
-
- // Calculate the distance of the pixel from the line in pixels.
- float dist = length(v_normal) * v_width2.s;
-
- // Calculate the antialiasing fade factor. This is either when fading in
- // the line in case of an offset line (v_width2.t) or when fading out
- // (v_width2.s)
- float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;
- float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);
-
- float sdfdist_a = texture2D(u_image, v_tex_a).a;
- float sdfdist_b = texture2D(u_image, v_tex_b).a;
- float sdfdist = mix(sdfdist_a, sdfdist_b, u_mix);
- alpha *= smoothstep(0.5 - u_sdfgamma / floorwidth, 0.5 + u_sdfgamma / floorwidth, sdfdist);
-
- gl_FragColor = color * (alpha * opacity);
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* line_sdf::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x95, 0x58, 0x6d, 0x6f, 0xdb, 0x36,
+ 0x10, 0xfe, 0xee, 0x5f, 0x71, 0x68, 0x3f, 0xd4,
+ 0x76, 0x1d, 0xf9, 0xa5, 0x69, 0x5a, 0x34, 0xc8,
+ 0x86, 0xa0, 0xcb, 0x36, 0x0f, 0x59, 0x5a, 0x34,
+ 0xed, 0xb6, 0x6f, 0x02, 0x2d, 0xd1, 0x36, 0x37,
+ 0x49, 0xf4, 0x44, 0xca, 0x2f, 0x1d, 0xf6, 0xdf,
+ 0x77, 0x47, 0x91, 0x12, 0x65, 0xcb, 0x6a, 0x16,
+ 0x38, 0xb0, 0xcc, 0x7b, 0x7b, 0x78, 0xbc, 0x3b,
+ 0xdd, 0x71, 0x3c, 0x86, 0x65, 0x22, 0x65, 0xde,
+ 0x9f, 0xce, 0xde, 0xc0, 0x18, 0x66, 0x03, 0xb8,
+ 0xb9, 0x81, 0xab, 0x57, 0xc1, 0xa4, 0x37, 0x1e,
+ 0x83, 0x5e, 0x73, 0x48, 0xd9, 0x5e, 0xa4, 0x45,
+ 0x0a, 0x2c, 0x49, 0xe4, 0x8e, 0xc7, 0x90, 0x0a,
+ 0xcd, 0x73, 0x48, 0x04, 0x7e, 0x83, 0x50, 0x30,
+ 0x0b, 0x26, 0xc0, 0x74, 0xc9, 0x29, 0x53, 0x9e,
+ 0xe9, 0xc0, 0x3c, 0xf3, 0xbd, 0xce, 0x8b, 0x98,
+ 0x43, 0x26, 0xf3, 0x94, 0x25, 0xc8, 0x48, 0xea,
+ 0x94, 0x96, 0x39, 0x6a, 0x10, 0x19, 0x30, 0x58,
+ 0x1c, 0x34, 0x87, 0xfe, 0xc5, 0x74, 0xf6, 0x36,
+ 0x08, 0xd0, 0xf4, 0x20, 0x80, 0x1d, 0x07, 0x15,
+ 0xb1, 0x84, 0x43, 0xce, 0x57, 0x45, 0xc2, 0x72,
+ 0x2b, 0xab, 0xa0, 0xd8, 0x80, 0x96, 0x90, 0xf0,
+ 0x6c, 0xa5, 0xd7, 0x08, 0x6d, 0x04, 0x8b, 0x42,
+ 0x5b, 0x74, 0x39, 0x07, 0x46, 0xff, 0x89, 0x92,
+ 0xf0, 0x4c, 0x6d, 0x78, 0x24, 0x58, 0xf2, 0xac,
+ 0x12, 0xd4, 0x6b, 0x44, 0xb6, 0x66, 0x5b, 0x4e,
+ 0xf6, 0xc4, 0x6a, 0x45, 0xb8, 0x4b, 0x2d, 0x7d,
+ 0xb9, 0xb4, 0x6a, 0xa7, 0xb3, 0x2b, 0x04, 0x54,
+ 0xaa, 0xc3, 0xed, 0x44, 0x4c, 0xf1, 0x41, 0x40,
+ 0x3f, 0x9f, 0xc7, 0x7c, 0x29, 0x32, 0x87, 0xc9,
+ 0x78, 0xa4, 0xb9, 0x34, 0x09, 0x26, 0xd3, 0xd7,
+ 0x6f, 0xdf, 0xbc, 0x9a, 0x4c, 0xaf, 0x7a, 0x24,
+ 0xf0, 0xbb, 0x23, 0xd0, 0xfe, 0x63, 0xa1, 0x34,
+ 0xcb, 0x22, 0x0e, 0x0b, 0xbe, 0x94, 0x84, 0x30,
+ 0x8e, 0x45, 0xb6, 0x02, 0xf4, 0x19, 0xda, 0x24,
+ 0x86, 0x45, 0xb1, 0x5c, 0xf2, 0x5c, 0x81, 0x92,
+ 0x25, 0x4c, 0xdc, 0x7d, 0xc4, 0xb2, 0xd2, 0x45,
+ 0xa4, 0x2d, 0x91, 0xc8, 0xee, 0xb4, 0x28, 0x40,
+ 0x25, 0xe5, 0x92, 0xe2, 0x2b, 0xf2, 0xb2, 0x0a,
+ 0xe0, 0x8b, 0xe2, 0x25, 0xe6, 0x2d, 0x4b, 0x0a,
+ 0x4e, 0x7a, 0x8b, 0xec, 0x14, 0x40, 0x50, 0xa1,
+ 0xbe, 0x9f, 0x3f, 0xdc, 0x85, 0x3f, 0xcc, 0x1f,
+ 0x3f, 0xdf, 0x3e, 0xbc, 0xbf, 0x0b, 0x1f, 0xdf,
+ 0xdf, 0xde, 0xdf, 0xd1, 0xe9, 0xf5, 0xdc, 0x41,
+ 0x57, 0x90, 0xe5, 0x16, 0x1d, 0xb5, 0x5b, 0x8b,
+ 0x68, 0x6d, 0xd6, 0x13, 0x12, 0xe6, 0xf1, 0x8a,
+ 0xc3, 0x92, 0xc5, 0x08, 0x45, 0x16, 0xda, 0x38,
+ 0xe8, 0x13, 0xd7, 0x22, 0x63, 0x10, 0xf3, 0xad,
+ 0x20, 0x84, 0x19, 0xc7, 0xa3, 0x65, 0xa0, 0xd0,
+ 0xf3, 0x09, 0xca, 0x57, 0xda, 0x10, 0x17, 0xdb,
+ 0x4a, 0x81, 0xb4, 0x44, 0x30, 0x85, 0x4e, 0xa8,
+ 0x11, 0xdd, 0x3e, 0x7c, 0x9e, 0xdf, 0xde, 0xcf,
+ 0x6f, 0x1f, 0xe7, 0x0f, 0x3f, 0xc1, 0x14, 0x03,
+ 0x69, 0x0c, 0x3f, 0xdc, 0xfd, 0x36, 0x47, 0x74,
+ 0x1f, 0xe7, 0x7f, 0xdc, 0xdd, 0x87, 0x9f, 0x6e,
+ 0x3f, 0xcf, 0x3f, 0x50, 0x50, 0x12, 0x4a, 0xa6,
+ 0x75, 0x2e, 0xf0, 0xe4, 0x39, 0x6c, 0x79, 0x74,
+ 0x09, 0x2c, 0xdc, 0x48, 0x15, 0x96, 0x27, 0x7d,
+ 0x7d, 0x4a, 0x8c, 0x99, 0x66, 0xd7, 0xbd, 0x5e,
+ 0x91, 0x09, 0xf4, 0x5c, 0x8a, 0x41, 0xac, 0x2f,
+ 0xa1, 0x08, 0xf1, 0x2b, 0x17, 0xfb, 0xeb, 0x7a,
+ 0x99, 0xc7, 0xa2, 0x48, 0x37, 0x94, 0x01, 0x78,
+ 0x04, 0x45, 0x98, 0x33, 0x2d, 0x64, 0x4d, 0x46,
+ 0x5d, 0x33, 0x5c, 0xdd, 0xa0, 0x76, 0x9e, 0x97,
+ 0xbe, 0x0d, 0x59, 0x4d, 0x76, 0x52, 0x9a, 0xef,
+ 0xc3, 0x83, 0x4f, 0x68, 0x93, 0x5b, 0x9c, 0x93,
+ 0x5b, 0x9c, 0xc8, 0xad, 0x92, 0x10, 0x57, 0xb4,
+ 0x0a, 0xb5, 0x0c, 0x37, 0x62, 0xcf, 0x13, 0x85,
+ 0x3b, 0xd9, 0xb2, 0xfc, 0x40, 0x11, 0x64, 0x78,
+ 0xb6, 0xd5, 0xc6, 0x8f, 0x96, 0x77, 0x22, 0xd6,
+ 0xeb, 0xd9, 0xc9, 0x32, 0x59, 0x62, 0xad, 0xab,
+ 0x8b, 0x7a, 0xb5, 0x84, 0xb5, 0x0d, 0x57, 0x2c,
+ 0x4d, 0x59, 0x68, 0x50, 0xa3, 0xdd, 0xde, 0x73,
+ 0xb1, 0xcc, 0xf0, 0xbc, 0xe0, 0xe7, 0xdb, 0xc7,
+ 0xf0, 0xcb, 0xc3, 0xfc, 0xc7, 0x0f, 0x9f, 0x7e,
+ 0x0d, 0x8b, 0x30, 0x92, 0x89, 0xcc, 0x2b, 0xe0,
+ 0x58, 0x19, 0x9c, 0x13, 0x59, 0x49, 0x0a, 0xb5,
+ 0x7f, 0x28, 0x6b, 0xb1, 0x5a, 0x6f, 0xdc, 0xd1,
+ 0x18, 0x7a, 0x6d, 0xd6, 0xa3, 0x59, 0xca, 0x73,
+ 0xdc, 0x31, 0xaf, 0x74, 0x7b, 0xf4, 0x22, 0xac,
+ 0x38, 0xb2, 0x58, 0x2c, 0xcf, 0x82, 0x5b, 0x24,
+ 0xc5, 0x19, 0x6c, 0x44, 0x69, 0x42, 0x33, 0x64,
+ 0xe3, 0x90, 0x92, 0x5a, 0x03, 0xf3, 0x04, 0x4b,
+ 0x42, 0x13, 0x97, 0x47, 0x2e, 0x42, 0xc7, 0xd0,
+ 0x09, 0x4b, 0x6e, 0x58, 0x24, 0xf4, 0xa1, 0x1d,
+ 0x99, 0x25, 0x9e, 0x07, 0x67, 0x19, 0x5a, 0xf1,
+ 0x55, 0xb4, 0x0e, 0x88, 0x1e, 0x4f, 0x27, 0xca,
+ 0x15, 0xdb, 0x98, 0x28, 0x6a, 0x87, 0xe9, 0xa8,
+ 0x4d, 0x9c, 0x2e, 0x8f, 0x2c, 0x54, 0xc7, 0x74,
+ 0x8c, 0xe7, 0x38, 0xdd, 0x7c, 0xbe, 0x6e, 0xcf,
+ 0x2d, 0x97, 0x8a, 0xeb, 0x33, 0x8e, 0x33, 0xb4,
+ 0x0e, 0xbf, 0x19, 0x7a, 0xb7, 0x6b, 0x2a, 0x96,
+ 0x4e, 0x14, 0x1d, 0x6e, 0xf9, 0xb6, 0x4f, 0xec,
+ 0x46, 0xdd, 0xe1, 0x35, 0x5d, 0xf1, 0x24, 0x6f,
+ 0x3d, 0xcd, 0x55, 0xe6, 0x65, 0xde, 0x81, 0xb4,
+ 0xa6, 0x9f, 0x77, 0x59, 0xcd, 0xd3, 0x1a, 0x6d,
+ 0x3e, 0xb9, 0xc3, 0xab, 0x4d, 0x36, 0x0b, 0xda,
+ 0xbc, 0x09, 0x52, 0x26, 0xb2, 0xfe, 0x00, 0xfe,
+ 0xe9, 0x01, 0xfe, 0x75, 0x16, 0x18, 0x62, 0x30,
+ 0x4f, 0x70, 0x83, 0x6f, 0x37, 0x8c, 0xe0, 0xbf,
+ 0xc2, 0x54, 0xec, 0x43, 0xaa, 0x06, 0x7d, 0x5b,
+ 0x49, 0x46, 0x75, 0xc9, 0x19, 0x38, 0x3c, 0x24,
+ 0x76, 0x5c, 0x57, 0x48, 0xc3, 0x71, 0xfd, 0xe8,
+ 0xb0, 0x6f, 0x6a, 0x08, 0xd1, 0xe9, 0xe1, 0xc4,
+ 0xfa, 0xac, 0x5f, 0x56, 0x8b, 0x51, 0x55, 0x53,
+ 0x1a, 0xb6, 0x8f, 0x4a, 0x87, 0x31, 0xdd, 0x2c,
+ 0x11, 0x1d, 0x96, 0x5d, 0x99, 0x20, 0x16, 0xfb,
+ 0xdc, 0x6a, 0xdf, 0xd2, 0x46, 0x7e, 0xf1, 0x38,
+ 0x87, 0xc2, 0xd3, 0x73, 0x5a, 0x08, 0x3a, 0xb0,
+ 0x54, 0xc5, 0x80, 0x78, 0x9a, 0x01, 0xe9, 0x48,
+ 0xad, 0xd8, 0x1c, 0x71, 0xd4, 0x28, 0x19, 0x0d,
+ 0x74, 0xe7, 0xb5, 0xb5, 0xd4, 0x85, 0x2e, 0x77,
+ 0x95, 0xb5, 0xe1, 0x78, 0xc3, 0x66, 0xb5, 0xdd,
+ 0x6f, 0x86, 0x34, 0xf2, 0x4a, 0xc7, 0x59, 0xaf,
+ 0x55, 0x4a, 0x4e, 0x4a, 0x44, 0x07, 0xa0, 0xda,
+ 0x61, 0xe7, 0xfd, 0x53, 0x39, 0xe7, 0xdb, 0x9e,
+ 0xa9, 0xdd, 0xf2, 0x74, 0x9f, 0x78, 0x45, 0x80,
+ 0xb8, 0xea, 0x9f, 0xad, 0x60, 0x6a, 0xf2, 0xe8,
+ 0xa8, 0x40, 0x9c, 0x73, 0x4c, 0x53, 0x61, 0x7b,
+ 0xa6, 0x93, 0x88, 0xad, 0x27, 0x6e, 0x18, 0xb8,
+ 0xb1, 0x8d, 0x59, 0xb0, 0x3f, 0xc0, 0x05, 0x50,
+ 0xeb, 0x3f, 0xb9, 0x76, 0x00, 0x4d, 0x71, 0x8a,
+ 0x45, 0xce, 0x23, 0x6c, 0xc1, 0x32, 0x64, 0x4d,
+ 0x65, 0xdc, 0xb7, 0xec, 0x5f, 0x47, 0x70, 0x19,
+ 0x4c, 0x06, 0x24, 0x73, 0x2c, 0x41, 0xcd, 0xa9,
+ 0x92, 0x4b, 0x46, 0x39, 0xd6, 0x2f, 0x07, 0x19,
+ 0x27, 0x84, 0x8d, 0xa3, 0x91, 0x7a, 0xe9, 0xac,
+ 0xee, 0x60, 0x08, 0x57, 0x66, 0x69, 0xd8, 0xd6,
+ 0x0c, 0x5f, 0x7b, 0x98, 0xb1, 0xb7, 0x34, 0x68,
+ 0xeb, 0x1e, 0x13, 0x31, 0x5b, 0x06, 0x6c, 0x7d,
+ 0xf7, 0x34, 0xf9, 0x4c, 0x41, 0x2c, 0xb1, 0xa1,
+ 0x7f, 0xa1, 0xb0, 0xeb, 0xcd, 0x65, 0x91, 0xc5,
+ 0xd8, 0xc0, 0x6f, 0x46, 0x30, 0x01, 0x49, 0x83,
+ 0xc9, 0x4e, 0x58, 0xb7, 0x21, 0xfb, 0xa1, 0x62,
+ 0xa7, 0x7e, 0xda, 0x8e, 0x44, 0x1b, 0x29, 0xb0,
+ 0x8d, 0xc7, 0x29, 0x04, 0x9d, 0x8e, 0xb2, 0x17,
+ 0x56, 0x9d, 0x5b, 0x8f, 0xe5, 0x2e, 0x6b, 0x44,
+ 0x83, 0xc1, 0x65, 0x65, 0x8f, 0xa0, 0x7d, 0xdd,
+ 0x95, 0x4e, 0x71, 0x6d, 0x21, 0xd2, 0x5d, 0x7f,
+ 0xe8, 0x20, 0xa0, 0x61, 0x1a, 0x17, 0x72, 0x96,
+ 0x29, 0xaa, 0xd4, 0xd4, 0xe7, 0x66, 0x68, 0x5c,
+ 0x61, 0xcf, 0x8e, 0x0d, 0xfa, 0x02, 0x07, 0x94,
+ 0xcd, 0x26, 0x11, 0xe5, 0x70, 0x46, 0x20, 0x7f,
+ 0x79, 0x34, 0xa8, 0x32, 0x64, 0xc4, 0xf1, 0x29,
+ 0x92, 0x78, 0x7a, 0x0b, 0x1c, 0x8d, 0x54, 0xe0,
+ 0x14, 0xa6, 0x38, 0x25, 0xc4, 0xc4, 0x9a, 0xa2,
+ 0x88, 0x9d, 0x69, 0xd4, 0x1a, 0x07, 0x84, 0xdc,
+ 0xcc, 0x2a, 0x11, 0x0e, 0x70, 0x54, 0x70, 0x48,
+ 0x89, 0x12, 0x29, 0xea, 0xa6, 0x9a, 0x53, 0x4a,
+ 0x7b, 0xb9, 0x5e, 0x3d, 0x9a, 0x26, 0xdf, 0x3f,
+ 0xda, 0x35, 0x4b, 0x96, 0x8e, 0xeb, 0x84, 0xa5,
+ 0x4a, 0xcc, 0x0b, 0x9a, 0x1a, 0x86, 0xe0, 0xb2,
+ 0xd3, 0x93, 0x17, 0x59, 0xc9, 0x51, 0x59, 0x78,
+ 0x09, 0xfd, 0xea, 0xf9, 0x3b, 0x1a, 0xde, 0xe0,
+ 0xfb, 0xe6, 0x00, 0xf2, 0x8e, 0x16, 0x07, 0x3e,
+ 0x06, 0x9c, 0x74, 0x4e, 0x94, 0xd4, 0xb8, 0x86,
+ 0x2d, 0x0a, 0x69, 0x1a, 0x7e, 0x47, 0x51, 0x4a,
+ 0x61, 0xd7, 0xf7, 0xf6, 0x70, 0x63, 0x19, 0x26,
+ 0x86, 0xc1, 0xb7, 0x3b, 0xa8, 0x0f, 0xe9, 0xb1,
+ 0x9a, 0xde, 0x4c, 0xc6, 0x28, 0x4a, 0x04, 0x3c,
+ 0x76, 0x1c, 0x09, 0x4d, 0x38, 0x98, 0x51, 0xca,
+ 0x85, 0x00, 0x39, 0x16, 0x39, 0x33, 0x1a, 0x63,
+ 0x17, 0x87, 0x7a, 0x50, 0xab, 0xb3, 0x1e, 0x15,
+ 0xca, 0xa5, 0x9d, 0x10, 0x79, 0x8e, 0xcd, 0x7e,
+ 0x70, 0x1a, 0x4f, 0x34, 0xa5, 0xc1, 0x8d, 0xdd,
+ 0xe7, 0xd0, 0x4b, 0xd5, 0x21, 0xb8, 0x01, 0xc0,
+ 0xaa, 0x7a, 0xcf, 0x92, 0x08, 0xa7, 0x72, 0x5d,
+ 0xe2, 0xb3, 0x07, 0xb0, 0x23, 0x00, 0x71, 0xce,
+ 0x76, 0xd4, 0x21, 0xb0, 0x12, 0x80, 0x99, 0x66,
+ 0xd1, 0xa6, 0x8b, 0x09, 0x11, 0xf3, 0x12, 0x07,
+ 0xc6, 0x58, 0xa4, 0x0b, 0x84, 0x4e, 0x6c, 0x55,
+ 0x1c, 0xe1, 0xd4, 0x1c, 0xcb, 0x12, 0x25, 0x6e,
+ 0x23, 0xca, 0x39, 0x46, 0x9c, 0x51, 0x66, 0x37,
+ 0x6e, 0xd4, 0xd9, 0x9c, 0xd0, 0x72, 0xc7, 0xf2,
+ 0x58, 0xf9, 0x17, 0x0c, 0xe6, 0x32, 0x00, 0xd3,
+ 0x4f, 0x23, 0x32, 0xa7, 0x52, 0x58, 0x60, 0x3b,
+ 0xfe, 0x02, 0x27, 0x6f, 0x07, 0xaf, 0x4c, 0x51,
+ 0xac, 0x4e, 0x4e, 0x5b, 0xbf, 0x59, 0x6f, 0x30,
+ 0x01, 0xd1, 0xdc, 0x74, 0x80, 0x88, 0xcd, 0xd8,
+ 0xba, 0xe6, 0x22, 0x77, 0x1a, 0x9d, 0x57, 0x2c,
+ 0x26, 0xab, 0x80, 0xee, 0x31, 0x32, 0x93, 0xec,
+ 0x50, 0x29, 0x0a, 0x5a, 0x2a, 0x78, 0x01, 0x74,
+ 0xfa, 0xaf, 0x8d, 0x7f, 0x2b, 0xc6, 0xeb, 0x16,
+ 0x46, 0x0a, 0x35, 0x0a, 0xe8, 0x0b, 0x60, 0x0b,
+ 0xd5, 0x2f, 0x06, 0xd7, 0xa7, 0x07, 0x56, 0x3a,
+ 0x7e, 0x86, 0x8c, 0xf6, 0x08, 0x5a, 0x0e, 0x0d,
+ 0xbf, 0x6d, 0x61, 0x38, 0xe0, 0x23, 0xe6, 0xfa,
+ 0xac, 0x8f, 0xaf, 0xbb, 0x8b, 0x62, 0x04, 0xf8,
+ 0xd1, 0x83, 0xba, 0xce, 0x5d, 0xc2, 0x26, 0x97,
+ 0x7f, 0x22, 0x1e, 0x1e, 0x7b, 0x35, 0xda, 0x8d,
+ 0xc9, 0x28, 0x6b, 0xfa, 0x2c, 0x13, 0x23, 0x63,
+ 0x37, 0x1d, 0x8f, 0x28, 0x84, 0x47, 0x5e, 0xaa,
+ 0xe0, 0xb4, 0xfa, 0x51, 0x2a, 0x61, 0xbd, 0x78,
+ 0x2c, 0x4c, 0x85, 0xf4, 0x65, 0x85, 0xfa, 0x58,
+ 0x8b, 0x4d, 0x94, 0x13, 0x14, 0x75, 0xd8, 0x45,
+ 0x55, 0xd8, 0xad, 0xe5, 0x0e, 0xd2, 0xc2, 0xde,
+ 0x49, 0x6c, 0x78, 0x4e, 0xb7, 0x3d, 0xa6, 0x38,
+ 0x6d, 0x05, 0xdf, 0x81, 0xfa, 0xbb, 0x10, 0x6a,
+ 0x4d, 0xb7, 0x13, 0x39, 0x28, 0x9d, 0x73, 0x1d,
+ 0xd1, 0x0f, 0x2f, 0x50, 0xbc, 0xb4, 0xb6, 0x2b,
+ 0x61, 0x79, 0x17, 0x84, 0xaf, 0x55, 0xbd, 0xc6,
+ 0x0c, 0x08, 0x7d, 0x9d, 0x37, 0xf6, 0xa2, 0xc8,
+ 0x6c, 0xbe, 0x51, 0x13, 0x5a, 0x84, 0xdb, 0x25,
+ 0x4f, 0x36, 0x45, 0x6f, 0xbd, 0xb1, 0xef, 0x2e,
+ 0xf3, 0x42, 0x6a, 0x1b, 0xf7, 0x07, 0xae, 0x9c,
+ 0x7b, 0xa3, 0x38, 0x2a, 0x7e, 0x02, 0xee, 0xf1,
+ 0xb7, 0xf0, 0xb9, 0xc3, 0x2f, 0xaf, 0x04, 0x50,
+ 0xa9, 0xed, 0x01, 0xea, 0xf7, 0xe8, 0xf0, 0xe4,
+ 0xc6, 0x23, 0xd8, 0xc3, 0x18, 0xfc, 0x26, 0xc1,
+ 0x8b, 0xae, 0x13, 0xde, 0x03, 0x9e, 0x67, 0x75,
+ 0x25, 0x52, 0x6d, 0xc4, 0x5c, 0x35, 0x3c, 0xc9,
+ 0xda, 0xe2, 0x7f, 0x58, 0x5b, 0x34, 0xac, 0x2d,
+ 0xaa, 0xc8, 0xb6, 0xd7, 0x20, 0xce, 0x5e, 0x59,
+ 0xde, 0x46, 0xe5, 0x2b, 0x01, 0x99, 0xfe, 0xed,
+ 0xfd, 0x07, 0xb4, 0x2b, 0xfd, 0x49
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* line_sdf::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x85, 0x55, 0x5d, 0x6f, 0x9b, 0x30,
+ 0x14, 0x7d, 0xe7, 0x57, 0x5c, 0xa9, 0x2f, 0xd0,
+ 0x65, 0x34, 0x8b, 0xd6, 0xa7, 0xa8, 0x0f, 0x55,
+ 0x92, 0x6a, 0x91, 0xb6, 0xa6, 0x4a, 0xd3, 0x6e,
+ 0x6f, 0x96, 0x03, 0x06, 0x2c, 0x19, 0x1b, 0x61,
+ 0x93, 0xb6, 0x9a, 0xf6, 0xdf, 0xe7, 0x0f, 0x08,
+ 0x84, 0x40, 0x1a, 0x45, 0x48, 0xdc, 0x73, 0xef,
+ 0x39, 0xf7, 0xc3, 0xbe, 0x78, 0x15, 0xa7, 0x89,
+ 0x28, 0x73, 0x90, 0x38, 0x2f, 0x18, 0x29, 0x67,
+ 0x4b, 0xa8, 0x10, 0xcd, 0x71, 0x4a, 0xe6, 0x5e,
+ 0x03, 0x25, 0x4c, 0x60, 0xa5, 0xcd, 0x32, 0x4e,
+ 0x52, 0x9c, 0xe7, 0xf8, 0x1c, 0xc9, 0xe9, 0xfb,
+ 0xdc, 0xf3, 0x0e, 0xb8, 0xfc, 0xa0, 0x3c, 0x85,
+ 0x03, 0x89, 0x66, 0x70, 0x40, 0x5c, 0x7b, 0x60,
+ 0x36, 0xef, 0x9b, 0xdf, 0x68, 0xac, 0xb2, 0xd9,
+ 0x99, 0x59, 0x91, 0x77, 0x84, 0x07, 0xad, 0xfb,
+ 0xd6, 0xea, 0xf4, 0x0e, 0xc8, 0xa6, 0x81, 0x64,
+ 0x84, 0x99, 0x4e, 0xd3, 0xf3, 0xae, 0x68, 0xc2,
+ 0x63, 0x92, 0xc0, 0x8f, 0xfb, 0x67, 0xf4, 0xf2,
+ 0xb8, 0x7e, 0xd8, 0x6c, 0x7f, 0xa1, 0x0a, 0x45,
+ 0x82, 0x89, 0xf2, 0x18, 0x9a, 0xd1, 0x34, 0x2b,
+ 0x0c, 0xed, 0x77, 0xb0, 0xc0, 0xdc, 0xbb, 0x22,
+ 0x4c, 0x92, 0x63, 0x29, 0x1d, 0xbc, 0x0e, 0x35,
+ 0x1e, 0x3c, 0xa6, 0xc9, 0xa8, 0xc0, 0x9e, 0x55,
+ 0x2d, 0x3f, 0x13, 0x6f, 0x45, 0x9d, 0x9f, 0xb1,
+ 0xf7, 0xe9, 0x3b, 0xb0, 0x0b, 0xfc, 0x94, 0x5d,
+ 0x14, 0x38, 0xa2, 0xea, 0x63, 0x48, 0xa0, 0x86,
+ 0x2e, 0x6a, 0x74, 0x7c, 0x2e, 0xca, 0xd8, 0x71,
+ 0x1c, 0x45, 0x72, 0x12, 0xd3, 0x2a, 0x6f, 0x58,
+ 0x2c, 0xd6, 0x57, 0x39, 0x75, 0xa9, 0x09, 0x3e,
+ 0x95, 0xd1, 0xde, 0xa2, 0x3c, 0xd5, 0xea, 0xa4,
+ 0xdb, 0xa2, 0x17, 0x6b, 0x3a, 0x75, 0xab, 0xf5,
+ 0x0e, 0x82, 0xc6, 0x90, 0x63, 0xca, 0xfd, 0x00,
+ 0xfe, 0x7a, 0xa0, 0x7f, 0x26, 0x85, 0xb1, 0xe3,
+ 0x60, 0xf0, 0xfe, 0x51, 0x80, 0xbb, 0xf3, 0x91,
+ 0x8f, 0xf3, 0xd8, 0xa9, 0x1b, 0xb8, 0x37, 0x71,
+ 0xcb, 0x72, 0x3a, 0xd9, 0x71, 0x92, 0x66, 0xb8,
+ 0x3d, 0x9e, 0xda, 0x6c, 0xa9, 0xce, 0x06, 0x38,
+ 0xce, 0xe6, 0xfa, 0x6a, 0xf0, 0x81, 0xf9, 0x59,
+ 0xb2, 0x5e, 0xd3, 0xc6, 0xa9, 0x3a, 0x73, 0xea,
+ 0xe5, 0xd6, 0x22, 0x96, 0x71, 0x70, 0x16, 0x26,
+ 0xe4, 0xe6, 0x06, 0x16, 0x98, 0x45, 0x15, 0xc3,
+ 0x8a, 0x80, 0xca, 0x08, 0xc4, 0x54, 0x2a, 0xcc,
+ 0x23, 0x02, 0x22, 0xb1, 0xef, 0x05, 0x7d, 0x27,
+ 0x0c, 0x92, 0x52, 0xe4, 0xf6, 0x95, 0x51, 0x4e,
+ 0x80, 0x72, 0x67, 0x96, 0xa1, 0xe5, 0x70, 0x8a,
+ 0x26, 0x50, 0x6b, 0x31, 0xc2, 0x53, 0x95, 0xf9,
+ 0xcd, 0x42, 0x09, 0xe0, 0xfa, 0xb8, 0x45, 0x42,
+ 0x39, 0x1f, 0x11, 0xc5, 0x5c, 0x51, 0xcc, 0x28,
+ 0x96, 0x76, 0x6d, 0xe0, 0x98, 0xe8, 0x47, 0xa4,
+ 0x44, 0x19, 0xc2, 0x2e, 0xa3, 0x12, 0xf4, 0x9f,
+ 0x50, 0xed, 0x57, 0xc2, 0x5b, 0x46, 0xb8, 0x71,
+ 0x30, 0x7e, 0x94, 0x37, 0x64, 0xdd, 0xc4, 0x22,
+ 0x2c, 0x6d, 0xee, 0x98, 0xeb, 0x67, 0x22, 0x89,
+ 0x72, 0x88, 0x7f, 0x4c, 0x42, 0x05, 0x20, 0x4e,
+ 0x89, 0x44, 0xa5, 0x1a, 0xa6, 0xd6, 0x4d, 0x06,
+ 0x9d, 0xda, 0xcc, 0x41, 0x99, 0xe9, 0xe2, 0x7c,
+ 0x7b, 0x74, 0xbe, 0xc0, 0xb7, 0x70, 0x0a, 0x37,
+ 0xb0, 0x5c, 0xbd, 0xae, 0x17, 0x2b, 0xf4, 0xb4,
+ 0xfe, 0xb3, 0xfa, 0x89, 0xb6, 0xf7, 0xbb, 0xf5,
+ 0xc6, 0x55, 0x7b, 0xb2, 0xef, 0x5a, 0x12, 0xcc,
+ 0x8a, 0x0c, 0x6b, 0x92, 0x88, 0xe9, 0xe5, 0xed,
+ 0xe7, 0xfa, 0x0a, 0xd8, 0x96, 0x7d, 0xed, 0xe6,
+ 0xa6, 0xdf, 0xac, 0x56, 0x30, 0xe9, 0x74, 0x4d,
+ 0x1b, 0x8d, 0x67, 0xa0, 0x25, 0x2d, 0x38, 0x81,
+ 0x69, 0x38, 0x9d, 0x98, 0x24, 0x82, 0xba, 0xa1,
+ 0x4e, 0x40, 0x6f, 0x7c, 0xe3, 0x87, 0x8c, 0x88,
+ 0x5e, 0xc5, 0xaa, 0x2a, 0xc9, 0x6c, 0xe9, 0xd7,
+ 0x1f, 0x88, 0x49, 0xb3, 0xb5, 0x83, 0x10, 0xcf,
+ 0x07, 0x82, 0xf6, 0x97, 0x82, 0xf6, 0xc3, 0x41,
+ 0x3a, 0x44, 0x7f, 0x4b, 0xfc, 0xa3, 0xee, 0xa4,
+ 0x65, 0x9b, 0xb8, 0xef, 0x4c, 0xe0, 0xa2, 0x5c,
+ 0xe9, 0xd7, 0x77, 0x20, 0x73, 0x21, 0x54, 0x26,
+ 0x15, 0x29, 0xfc, 0x69, 0x78, 0xab, 0x0b, 0x6b,
+ 0xbf, 0x53, 0xba, 0xba, 0xf6, 0x94, 0x9a, 0x12,
+ 0x6f, 0x75, 0xa3, 0x47, 0xe1, 0x5a, 0xa8, 0x69,
+ 0x40, 0xca, 0xd0, 0x43, 0x89, 0xd3, 0x45, 0xbd,
+ 0x20, 0xdc, 0xa2, 0xb8, 0x06, 0xbf, 0x16, 0x6e,
+ 0xae, 0xaa, 0x71, 0xaf, 0x2f, 0xd2, 0xe6, 0x75,
+ 0xb5, 0x5d, 0x6e, 0xef, 0x7f, 0xa3, 0xf5, 0xe3,
+ 0xf3, 0xd3, 0x6a, 0xb1, 0xdb, 0x6c, 0x87, 0x88,
+ 0xcc, 0xda, 0xf1, 0x5d, 0xa3, 0xeb, 0x6b, 0xf3,
+ 0xcf, 0xfb, 0x0f, 0x29, 0x1c, 0x77, 0x3b
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/preludes.cpp b/src/mbgl/shaders/preludes.cpp
index 6baa488a10..6a3586f8fd 100644
--- a/src/mbgl/shaders/preludes.cpp
+++ b/src/mbgl/shaders/preludes.cpp
@@ -1,106 +1,158 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/preludes.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
-const char* vertexPrelude = R"MBGL_SHADER(
-#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_vec4(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;
-}
-
-)MBGL_SHADER";
-const char* fragmentPrelude = R"MBGL_SHADER(
-#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
-
-)MBGL_SHADER";
+const char* vertexPrelude = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0xad, 0x55, 0xdf, 0x8f, 0xdb, 0x44,
+ 0x10, 0x7e, 0xf7, 0x5f, 0x31, 0xe8, 0x5e, 0x12,
+ 0xf0, 0xf9, 0x92, 0x34, 0x77, 0xa0, 0x56, 0x7d,
+ 0x40, 0x08, 0x21, 0x24, 0x24, 0x1e, 0xa0, 0xf0,
+ 0x50, 0x1d, 0x96, 0x63, 0x8f, 0x9d, 0x55, 0xed,
+ 0x5d, 0x6b, 0x77, 0x9d, 0xdc, 0xb5, 0xe2, 0x7f,
+ 0x67, 0x66, 0x77, 0x1d, 0xaf, 0x9d, 0x2b, 0x2a,
+ 0x12, 0x91, 0x7c, 0xb9, 0x8c, 0xbf, 0x99, 0xf9,
+ 0xe6, 0xf7, 0x8d, 0xa8, 0x2b, 0xac, 0xe1, 0xa7,
+ 0x5f, 0xf2, 0x1f, 0x7f, 0x4b, 0x7a, 0x8d, 0xa5,
+ 0x30, 0x42, 0x49, 0x38, 0x8a, 0xe6, 0xd8, 0x43,
+ 0xdd, 0xaa, 0xc2, 0xbe, 0x49, 0x6e, 0xb0, 0x35,
+ 0x98, 0x24, 0x37, 0xa2, 0x86, 0xaf, 0x08, 0x2c,
+ 0x24, 0x56, 0xab, 0x56, 0x9d, 0xfb, 0x75, 0x72,
+ 0xe3, 0x7f, 0x02, 0xff, 0x22, 0x98, 0xac, 0x44,
+ 0xbd, 0xc0, 0x75, 0x58, 0x89, 0xa1, 0x8b, 0xa0,
+ 0x41, 0xf0, 0x32, 0xda, 0xb9, 0x9d, 0xb0, 0xee,
+ 0xe7, 0x84, 0x0c, 0xdf, 0x77, 0x77, 0xf0, 0x4e,
+ 0xf6, 0x45, 0xf9, 0x01, 0x0a, 0xe8, 0x0b, 0xa1,
+ 0x41, 0xd5, 0x70, 0x2a, 0xda, 0x01, 0x0d, 0xd8,
+ 0x63, 0x61, 0xe1, 0x58, 0x9c, 0x10, 0x0e, 0x88,
+ 0x12, 0x18, 0x84, 0x15, 0x08, 0x69, 0x15, 0x61,
+ 0x8d, 0x90, 0x4d, 0x8b, 0x3e, 0xa8, 0x8c, 0xad,
+ 0xfc, 0x7e, 0xc4, 0x11, 0x12, 0xf4, 0x0b, 0x8d,
+ 0x50, 0x18, 0x33, 0x10, 0x49, 0x20, 0x9d, 0x03,
+ 0xc2, 0x77, 0xb7, 0x07, 0x61, 0x61, 0x90, 0x46,
+ 0x34, 0xd2, 0x9b, 0xc2, 0x06, 0xb5, 0x49, 0xa1,
+ 0x90, 0x15, 0xc3, 0xd9, 0x4e, 0xb0, 0xd1, 0x8a,
+ 0x0f, 0x08, 0x46, 0xbd, 0x9e, 0x44, 0x7f, 0xb0,
+ 0x55, 0x78, 0xcb, 0x2e, 0x95, 0x5e, 0x09, 0xd9,
+ 0x0f, 0xf6, 0xfd, 0xe6, 0x71, 0x0d, 0x5f, 0xc3,
+ 0xee, 0xfe, 0x01, 0xbe, 0x01, 0x2f, 0xd9, 0x3e,
+ 0xa6, 0xc9, 0x09, 0xcb, 0x1d, 0x79, 0x61, 0xb5,
+ 0xdc, 0x11, 0x5c, 0x95, 0x4a, 0x1a, 0xeb, 0xc9,
+ 0xc6, 0xd6, 0xd6, 0xf0, 0x29, 0x01, 0xfa, 0x10,
+ 0x91, 0x20, 0xfe, 0x59, 0xda, 0xd1, 0x0f, 0x09,
+ 0x57, 0x31, 0xf6, 0xcd, 0x05, 0x7a, 0xda, 0xd0,
+ 0xeb, 0x05, 0xfe, 0x8e, 0x59, 0x78, 0x88, 0x46,
+ 0x3b, 0x68, 0x09, 0xcc, 0x62, 0x75, 0xda, 0xa4,
+ 0x4b, 0xe4, 0x2d, 0xeb, 0x3b, 0xd2, 0x64, 0xf2,
+ 0xef, 0x64, 0xc6, 0x56, 0xd1, 0x5f, 0x61, 0x9f,
+ 0x5f, 0xe0, 0xfb, 0xab, 0x7f, 0x13, 0x33, 0xa6,
+ 0x27, 0x48, 0x67, 0x6c, 0x2f, 0x48, 0xa2, 0x74,
+ 0x4d, 0xc8, 0xe7, 0x63, 0x52, 0x65, 0xd8, 0x76,
+ 0xf7, 0x6d, 0x46, 0x3c, 0x3b, 0x55, 0xcd, 0x4d,
+ 0xa4, 0xb0, 0xcb, 0x36, 0x6b, 0xcf, 0x92, 0x2b,
+ 0xac, 0xa0, 0x13, 0x52, 0x74, 0xe2, 0x23, 0x52,
+ 0x6f, 0x20, 0xc8, 0xa1, 0x3b, 0xa0, 0x6b, 0x98,
+ 0xc2, 0x5a, 0x2d, 0x0e, 0x83, 0xa5, 0xa2, 0x4b,
+ 0xc4, 0x0a, 0xab, 0x14, 0xce, 0x08, 0x28, 0x4b,
+ 0x55, 0x51, 0x0b, 0xc0, 0xfe, 0xb6, 0x54, 0x5d,
+ 0xaf, 0x24, 0x4a, 0xcb, 0x76, 0x4a, 0xd5, 0x2a,
+ 0x3d, 0xf6, 0xd1, 0xd8, 0x73, 0x8e, 0x97, 0x81,
+ 0x95, 0xc8, 0x30, 0x23, 0x31, 0x73, 0x5d, 0x53,
+ 0xf7, 0x40, 0xad, 0x5a, 0x9a, 0x07, 0xe3, 0xfa,
+ 0xe0, 0x7d, 0xa8, 0xbd, 0x33, 0x90, 0x69, 0x97,
+ 0xc4, 0xfb, 0xa9, 0x01, 0xbc, 0xb8, 0xf1, 0xe2,
+ 0x94, 0x15, 0x60, 0xa6, 0x70, 0xf8, 0x57, 0x05,
+ 0x78, 0xe4, 0x4a, 0xec, 0xa1, 0x42, 0x66, 0x9d,
+ 0xbb, 0x77, 0xa1, 0x0e, 0xae, 0x42, 0x3e, 0x9a,
+ 0xea, 0x07, 0x96, 0x8f, 0x55, 0x98, 0x12, 0xbb,
+ 0x5f, 0x39, 0x01, 0x7f, 0x66, 0x8d, 0x17, 0x6b,
+ 0xb9, 0x6e, 0xe5, 0x3e, 0xb9, 0xa7, 0x6c, 0x7f,
+ 0x01, 0x7c, 0x3b, 0xc1, 0x1d, 0xfa, 0x52, 0x88,
+ 0xab, 0x81, 0xa5, 0x6f, 0x6e, 0xcb, 0x30, 0x76,
+ 0xd2, 0x4f, 0x96, 0xee, 0x55, 0x5b, 0x58, 0x1e,
+ 0x5e, 0x7b, 0xe6, 0xf9, 0xa5, 0x92, 0x75, 0x59,
+ 0xe2, 0x7b, 0x2a, 0x38, 0xed, 0xc4, 0x53, 0xee,
+ 0xba, 0x22, 0x8a, 0x33, 0x6a, 0xf9, 0x14, 0xe2,
+ 0x3e, 0xb4, 0x8b, 0xa8, 0x49, 0x39, 0x9e, 0x0f,
+ 0x8a, 0x2e, 0x8d, 0x95, 0x79, 0x12, 0x49, 0xe7,
+ 0xff, 0xe0, 0xec, 0xea, 0x32, 0xa7, 0xbc, 0x9f,
+ 0x28, 0xef, 0x83, 0x57, 0x97, 0x34, 0xf3, 0x19,
+ 0xce, 0x0e, 0x47, 0xdd, 0xeb, 0x40, 0x34, 0x2e,
+ 0xb3, 0x2a, 0xbb, 0x14, 0xc4, 0x46, 0xa2, 0x58,
+ 0x82, 0x80, 0x6a, 0x11, 0x16, 0x80, 0xb7, 0x54,
+ 0x3c, 0x7d, 0xa1, 0xa5, 0xdd, 0xd2, 0xd2, 0xab,
+ 0x8b, 0xa5, 0x28, 0x8f, 0x23, 0xb3, 0xf4, 0x62,
+ 0x39, 0xce, 0x1d, 0xaf, 0x56, 0x55, 0xd7, 0x06,
+ 0x2d, 0x79, 0xeb, 0x69, 0x71, 0x1b, 0xe0, 0xab,
+ 0xa2, 0xce, 0x84, 0x96, 0xcf, 0xd0, 0x8b, 0x27,
+ 0xba, 0x29, 0x6e, 0xdd, 0x46, 0x79, 0x83, 0xb3,
+ 0xd2, 0x6d, 0x05, 0x4a, 0x8b, 0x46, 0x48, 0x97,
+ 0x60, 0x16, 0x62, 0xd5, 0xb0, 0x2d, 0xf7, 0xbf,
+ 0x15, 0x2d, 0xba, 0xb9, 0x72, 0x75, 0x0f, 0x0e,
+ 0xde, 0xfa, 0x35, 0xc0, 0x26, 0x29, 0x26, 0xa5,
+ 0x69, 0x94, 0x0d, 0x0d, 0xfc, 0x9a, 0x70, 0x0c,
+ 0xfd, 0xde, 0xba, 0x3b, 0x02, 0x1f, 0x95, 0xea,
+ 0xa0, 0xc5, 0x13, 0x3b, 0x26, 0x5b, 0xbc, 0xe9,
+ 0xf9, 0xa1, 0x3d, 0x2f, 0x5d, 0x71, 0x3d, 0xa5,
+ 0xff, 0x4c, 0xe7, 0x72, 0x49, 0x9a, 0xd6, 0xb4,
+ 0x60, 0x7a, 0x2c, 0x29, 0xd2, 0xf6, 0x19, 0x9a,
+ 0xa1, 0xd0, 0x05, 0xf5, 0x07, 0xb5, 0xca, 0xf6,
+ 0x01, 0xe8, 0x88, 0x18, 0xe7, 0xe5, 0x72, 0x61,
+ 0x6b, 0x2a, 0x45, 0x74, 0x65, 0x4d, 0x06, 0x7f,
+ 0xa2, 0x5b, 0x45, 0x14, 0x8d, 0xe6, 0x6d, 0x55,
+ 0x48, 0x77, 0xce, 0xb2, 0x10, 0x86, 0x3b, 0x56,
+ 0x53, 0x8c, 0x20, 0x0c, 0x15, 0xc9, 0x18, 0x77,
+ 0x93, 0x78, 0xeb, 0xd8, 0xb3, 0x0a, 0x8e, 0x42,
+ 0x87, 0xfa, 0x3b, 0x34, 0x69, 0xe4, 0x43, 0xdf,
+ 0xa3, 0xbe, 0x5c, 0xa3, 0xd8, 0x16, 0x8d, 0xec,
+ 0x5f, 0xdb, 0x87, 0xf5, 0x52, 0x81, 0xb6, 0x98,
+ 0x53, 0xb8, 0x4a, 0xef, 0x88, 0x5e, 0x54, 0x9a,
+ 0x28, 0x95, 0x45, 0x5b, 0x0e, 0x3c, 0x0f, 0x9e,
+ 0x16, 0x18, 0xd4, 0x02, 0x5d, 0xe4, 0xc6, 0x62,
+ 0x1f, 0x0e, 0xb4, 0x39, 0xaa, 0x81, 0x12, 0x4b,
+ 0xb9, 0xa0, 0xd7, 0x27, 0x8e, 0x95, 0x83, 0x19,
+ 0x33, 0xf3, 0xda, 0x9f, 0x97, 0x06, 0x6d, 0xde,
+ 0xd3, 0x96, 0x46, 0x2d, 0xf3, 0x5e, 0x99, 0xd9,
+ 0xbc, 0x2f, 0x83, 0x1a, 0x27, 0xe8, 0xea, 0xad,
+ 0x8b, 0xc0, 0x2f, 0xae, 0xd9, 0xbe, 0xf0, 0x66,
+ 0xb9, 0x4b, 0x16, 0xc3, 0x47, 0x05, 0xcd, 0x07,
+ 0x49, 0xc5, 0xca, 0xad, 0xca, 0x7d, 0x4b, 0xcc,
+ 0x8d, 0x2b, 0xc3, 0xf3, 0x39, 0x8e, 0xd5, 0xa2,
+ 0x07, 0xc7, 0xe7, 0x05, 0x82, 0xb1, 0xcf, 0xb0,
+ 0xce, 0xb3, 0xcd, 0x67, 0xc4, 0xb4, 0xe7, 0xaf,
+ 0x83, 0x98, 0x43, 0x67, 0xe3, 0xb8, 0x7a, 0x89,
+ 0x36, 0x19, 0x23, 0xb2, 0x64, 0xca, 0x33, 0xe4,
+ 0xbd, 0x1c, 0x5b, 0xe0, 0x41, 0xfd, 0x07, 0x79,
+ 0x3f, 0x51, 0xf4
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* fragmentPrelude = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x53, 0xce, 0x4c, 0x4b, 0x49, 0x4d,
+ 0x53, 0x70, 0xf7, 0x89, 0x77, 0x0d, 0xe6, 0x2a,
+ 0x28, 0x4a, 0x4d, 0xce, 0x2c, 0xce, 0xcc, 0xcf,
+ 0x53, 0xc8, 0x4d, 0x4d, 0xc9, 0x2c, 0xcd, 0x2d,
+ 0x50, 0x48, 0xcb, 0xc9, 0x4f, 0x2c, 0xb1, 0xe6,
+ 0x52, 0x4e, 0xcd, 0x29, 0x4e, 0xe5, 0xe2, 0x52,
+ 0xce, 0x4c, 0x53, 0x50, 0x04, 0x2a, 0xcf, 0xcc,
+ 0x4b, 0x4d, 0xd1, 0xc8, 0xc9, 0x2f, 0x2f, 0xd0,
+ 0xe4, 0x52, 0x86, 0x70, 0x15, 0x40, 0x3c, 0xa0,
+ 0xb2, 0xbc, 0x94, 0xcc, 0x34, 0x34, 0x75, 0x50,
+ 0xa3, 0x10, 0x4a, 0xa1, 0x02, 0xd8, 0x55, 0x67,
+ 0x64, 0xa6, 0x67, 0x20, 0xa9, 0x05, 0x73, 0x11,
+ 0x2a, 0x21, 0x34, 0x00, 0x05, 0x35, 0x3a, 0xbd
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/raster.cpp b/src/mbgl/shaders/raster.cpp
index 98291bfec6..e28cb5b726 100644
--- a/src/mbgl/shaders/raster.cpp
+++ b/src/mbgl/shaders/raster.cpp
@@ -1,90 +1,143 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/raster.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* raster::name = "raster";
-const char* raster::vertexSource = R"MBGL_SHADER(
-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);
- // 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;
-}
-
-)MBGL_SHADER";
-const char* raster::fragmentSource = R"MBGL_SHADER(
-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() {
-
- // read and cross-fade colors from the main and parent tiles
- 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;
-
- // 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);
-
- gl_FragColor = vec4(mix(u_high_vec, u_low_vec, rgb) * color.a, color.a);
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* raster::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x75, 0x92, 0xcb, 0x4e, 0xc3, 0x40,
+ 0x0c, 0x45, 0xf7, 0xf9, 0x0a, 0x2f, 0x13, 0x28,
+ 0x6d, 0x83, 0x00, 0x81, 0x22, 0x96, 0x5d, 0xb0,
+ 0x41, 0x2c, 0x2a, 0xc1, 0xae, 0x9a, 0x26, 0x4e,
+ 0x63, 0x69, 0x32, 0x53, 0xe6, 0x51, 0x40, 0x88,
+ 0x7f, 0xc7, 0x4e, 0x9a, 0x36, 0xe5, 0x91, 0x4d,
+ 0x24, 0x3f, 0xce, 0xbd, 0xb6, 0x27, 0x1a, 0xaa,
+ 0xad, 0x6b, 0xa1, 0x55, 0xe1, 0x0a, 0xe2, 0x8a,
+ 0x7f, 0x8e, 0xde, 0x8b, 0x24, 0xee, 0xc3, 0x3b,
+ 0x2c, 0x2f, 0x39, 0x1c, 0xf4, 0x6a, 0xab, 0x1c,
+ 0x9a, 0x70, 0xcc, 0xd4, 0xda, 0xaa, 0xc0, 0x29,
+ 0x5f, 0x2a, 0x8d, 0xff, 0x66, 0xd7, 0xb1, 0xae,
+ 0xd1, 0xf5, 0x45, 0x45, 0x92, 0xa8, 0xc0, 0xf8,
+ 0x75, 0x0c, 0xd8, 0x83, 0xd5, 0x6a, 0x6b, 0x7d,
+ 0xf1, 0x3b, 0x1a, 0xf0, 0x3d, 0x44, 0x87, 0x7d,
+ 0x36, 0xd9, 0x29, 0xf7, 0x41, 0x66, 0xd3, 0x27,
+ 0x77, 0x12, 0x9c, 0x17, 0x7f, 0x04, 0x73, 0x29,
+ 0xb5, 0x54, 0xf1, 0x28, 0x64, 0xd2, 0x0c, 0x3e,
+ 0x13, 0xe0, 0x6f, 0xa3, 0x57, 0x4f, 0xd6, 0x53,
+ 0x20, 0x6b, 0xe0, 0xfe, 0x30, 0x20, 0x9c, 0x49,
+ 0xe3, 0x55, 0xda, 0x19, 0x98, 0xc0, 0x7c, 0x02,
+ 0x79, 0x56, 0x74, 0xf5, 0xb3, 0x19, 0x3c, 0x23,
+ 0xf0, 0x34, 0x10, 0xbd, 0xf0, 0x1f, 0x4c, 0xc8,
+ 0x6f, 0x80, 0x67, 0x82, 0xbd, 0x29, 0xd8, 0x0e,
+ 0xb8, 0xd2, 0x5a, 0x57, 0x91, 0x51, 0x01, 0x3d,
+ 0x04, 0x0b, 0x1b, 0xda, 0x49, 0x13, 0xa0, 0xb1,
+ 0x71, 0xd3, 0xc0, 0xd6, 0x61, 0x49, 0x5e, 0xea,
+ 0xb8, 0x79, 0x40, 0xd7, 0x4e, 0x95, 0xd2, 0xab,
+ 0xf4, 0xb8, 0x7b, 0x2a, 0x92, 0xd1, 0x23, 0xdc,
+ 0xe6, 0x77, 0x97, 0x82, 0xea, 0xd6, 0x05, 0xa1,
+ 0xc1, 0x83, 0xe8, 0x58, 0x8b, 0x4c, 0x97, 0xea,
+ 0x57, 0x3b, 0x90, 0x95, 0x07, 0x65, 0xd8, 0xf7,
+ 0x9a, 0x82, 0x53, 0x8e, 0xf4, 0x07, 0x34, 0xc4,
+ 0x2e, 0x4c, 0x6c, 0xd7, 0xe8, 0x84, 0xc9, 0x7e,
+ 0x3c, 0x3a, 0xb6, 0xa8, 0x2a, 0x7c, 0x8d, 0x0c,
+ 0x1a, 0x39, 0x7c, 0x6b, 0xd0, 0x00, 0x1f, 0xb0,
+ 0x42, 0xc7, 0x33, 0x4f, 0x07, 0xe6, 0xb2, 0x21,
+ 0x56, 0x63, 0xb0, 0xf6, 0xb6, 0x93, 0xf4, 0xaa,
+ 0xe5, 0x1b, 0x29, 0x1d, 0x51, 0xf4, 0x24, 0xb2,
+ 0x78, 0x59, 0x2e, 0x1e, 0x97, 0xf0, 0x36, 0x5e,
+ 0x99, 0x2c, 0xcb, 0x46, 0x16, 0x25, 0x3d, 0xb8,
+ 0x94, 0xa5, 0x8d, 0x67, 0x98, 0x0c, 0x12, 0x0c,
+ 0xe6, 0x8b, 0x34, 0x5d, 0x4f, 0x6b, 0x2b, 0xaa,
+ 0xbb, 0xa3, 0x22, 0x31, 0xdb, 0x89, 0x74, 0x69,
+ 0x8d, 0x27, 0x1f, 0xf8, 0x6d, 0xf5, 0xae, 0xfa,
+ 0xf3, 0xf3, 0x25, 0xd3, 0x34, 0x3d, 0x79, 0x27,
+ 0x30, 0xeb, 0xb6, 0x37, 0x9d, 0x67, 0x70, 0x01,
+ 0xf3, 0xe9, 0x75, 0xc6, 0x81, 0xd3, 0xe7, 0x07,
+ 0x19, 0x9c, 0x4b, 0xa6, 0x38, 0x82, 0x72, 0x01,
+ 0xed, 0x91, 0x67, 0x3f, 0xde, 0xb2, 0x54, 0x9f,
+ 0x3c, 0xfc, 0xaf, 0xe4, 0x1b, 0x93, 0x50, 0x12,
+ 0x27
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* raster::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x8d, 0x53, 0x4d, 0x6f, 0x9c, 0x30,
+ 0x10, 0xbd, 0xf3, 0x2b, 0x46, 0xca, 0x05, 0x12,
+ 0x87, 0x85, 0xdd, 0xf6, 0x84, 0x52, 0x29, 0xca,
+ 0x26, 0x52, 0x2f, 0x4d, 0xb5, 0xad, 0xda, 0x23,
+ 0xf2, 0x82, 0x61, 0x2d, 0x01, 0x5e, 0xd9, 0x86,
+ 0xec, 0x6e, 0x95, 0xff, 0xde, 0x31, 0x98, 0x8f,
+ 0xec, 0x47, 0x12, 0x4e, 0xc3, 0xcc, 0xf3, 0x7b,
+ 0x33, 0xcf, 0xe3, 0xba, 0xe2, 0x99, 0x90, 0x25,
+ 0x64, 0x85, 0xa0, 0x1a, 0xea, 0x38, 0xa3, 0x29,
+ 0x8b, 0x75, 0xe4, 0xd4, 0x47, 0x79, 0xb1, 0xa5,
+ 0x09, 0xd7, 0xfb, 0xb1, 0xa0, 0x68, 0xb9, 0x2d,
+ 0x98, 0x9c, 0x2f, 0xb1, 0xc8, 0x4b, 0x9a, 0xb3,
+ 0xe0, 0x9d, 0x5a, 0x18, 0x39, 0x0d, 0x95, 0x7b,
+ 0x5e, 0xe5, 0xd0, 0xb0, 0x64, 0x0e, 0x4d, 0xbc,
+ 0x15, 0x2a, 0x38, 0x97, 0x44, 0xe4, 0x89, 0xf6,
+ 0x5a, 0xf2, 0x7c, 0xa3, 0x2b, 0xa6, 0x54, 0x5c,
+ 0x88, 0x97, 0xe8, 0xbd, 0xfa, 0x06, 0xa3, 0x33,
+ 0x0c, 0x8a, 0xea, 0x5a, 0x52, 0xcd, 0x45, 0x85,
+ 0x03, 0x26, 0x5a, 0xc8, 0x53, 0x92, 0x44, 0x54,
+ 0x5a, 0x52, 0xa5, 0x4f, 0x00, 0xd8, 0xdb, 0xc2,
+ 0x50, 0x6c, 0x79, 0x15, 0xbf, 0x30, 0xa3, 0xa4,
+ 0x50, 0xa1, 0x11, 0x3c, 0x85, 0x92, 0xf2, 0xca,
+ 0xf5, 0xe0, 0x9f, 0xe3, 0x00, 0x7e, 0xb3, 0x19,
+ 0x48, 0x46, 0x53, 0xa0, 0x55, 0x0a, 0x89, 0x14,
+ 0x4a, 0xdd, 0x1a, 0x33, 0x21, 0x11, 0x85, 0x90,
+ 0x0a, 0x32, 0x29, 0x4a, 0xd0, 0x1b, 0xd6, 0x1e,
+ 0x6a, 0x31, 0x5b, 0x2a, 0x59, 0xa5, 0x41, 0xf3,
+ 0x82, 0xa9, 0x96, 0x00, 0x95, 0xbe, 0x74, 0xf0,
+ 0x00, 0xee, 0x40, 0xb3, 0x1d, 0x36, 0xcd, 0xe6,
+ 0x4b, 0xb7, 0x37, 0x98, 0x58, 0xdf, 0xbc, 0xe8,
+ 0x08, 0x1e, 0x9e, 0x83, 0x87, 0x16, 0x1e, 0x5a,
+ 0x38, 0xcf, 0xc0, 0xed, 0xc8, 0x7d, 0x0a, 0xdf,
+ 0x20, 0xf0, 0x03, 0xd3, 0x39, 0xd8, 0xcf, 0x56,
+ 0x64, 0xbe, 0x46, 0xae, 0xc9, 0xcf, 0xac, 0xff,
+ 0xa1, 0x1d, 0xcb, 0xeb, 0x5b, 0xae, 0xf0, 0x22,
+ 0x57, 0x38, 0xe5, 0x0a, 0xa7, 0x5c, 0xe1, 0x5b,
+ 0xae, 0x71, 0x0c, 0x44, 0x97, 0x7c, 0x67, 0x9b,
+ 0x24, 0x16, 0x4c, 0x86, 0xa5, 0xb4, 0x73, 0xb4,
+ 0x69, 0x94, 0xbd, 0xbe, 0x9b, 0xae, 0xa5, 0x65,
+ 0x5a, 0xc0, 0x44, 0xd5, 0x88, 0x46, 0xc3, 0xdd,
+ 0x98, 0x0b, 0x6c, 0xe3, 0x0e, 0x61, 0xc0, 0xee,
+ 0xd0, 0x72, 0x2a, 0xb4, 0x8b, 0x79, 0x72, 0x74,
+ 0xd1, 0xfe, 0x6e, 0x7f, 0xf0, 0xc8, 0x87, 0xa8,
+ 0xc3, 0x6e, 0xff, 0x09, 0xd4, 0xfe, 0xb0, 0xf3,
+ 0xbc, 0x49, 0x3f, 0xc3, 0x4e, 0xb6, 0x99, 0x6e,
+ 0x0f, 0x69, 0xc3, 0x24, 0xde, 0x1d, 0xf6, 0xe7,
+ 0xda, 0x11, 0xe0, 0xc6, 0x0e, 0x93, 0x0f, 0xd1,
+ 0xda, 0x43, 0x2b, 0x17, 0x7e, 0x10, 0x0d, 0xe3,
+ 0xdc, 0x20, 0xbe, 0x3f, 0x7a, 0x6b, 0x32, 0x1e,
+ 0x5c, 0x9f, 0x5f, 0xfb, 0x5e, 0xbd, 0x5f, 0xf7,
+ 0x89, 0x23, 0xa6, 0x69, 0x3c, 0x1d, 0xf8, 0x5f,
+ 0xbb, 0xd3, 0x47, 0x2f, 0x02, 0xe5, 0xb1, 0x34,
+ 0x32, 0x8c, 0xaf, 0x6e, 0x34, 0xbf, 0x6e, 0x1f,
+ 0x60, 0x8c, 0x71, 0xef, 0xf0, 0xf1, 0xeb, 0x25,
+ 0xf0, 0x71, 0xc6, 0x8b, 0xa6, 0x8c, 0x98, 0xb8,
+ 0x48, 0x68, 0xd4, 0x08, 0x7c, 0x26, 0xd5, 0x1b,
+ 0x9f, 0x17, 0xf1, 0x13, 0xda, 0xf4, 0x60, 0xf7,
+ 0xcd, 0x2c, 0x9f, 0x6b, 0x96, 0x6e, 0xec, 0x9c,
+ 0x8c, 0x9a, 0xa4, 0xb7, 0xd2, 0xee, 0x1c, 0xe9,
+ 0x03, 0xc3, 0x76, 0xc5, 0xb3, 0x94, 0x65, 0xf0,
+ 0xfc, 0xe7, 0x71, 0xb5, 0x5c, 0xdd, 0xff, 0x8d,
+ 0xbf, 0xff, 0xf8, 0xf5, 0xf3, 0xf1, 0xe1, 0xf7,
+ 0xf3, 0xea, 0xa2, 0x4e, 0xe8, 0x9b, 0xa7, 0x7b,
+ 0xc5, 0xaa, 0x94, 0x67, 0xce, 0xab, 0xf3, 0x1f,
+ 0x04, 0xbd, 0xc0, 0x04
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/symbol_icon.cpp b/src/mbgl/shaders/symbol_icon.cpp
index c037c81005..bfbb150951 100644
--- a/src/mbgl/shaders/symbol_icon.cpp
+++ b/src/mbgl/shaders/symbol_icon.cpp
@@ -1,149 +1,194 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/symbol_icon.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* symbol_icon::name = "symbol_icon";
-const char* symbol_icon::vertexSource = R"MBGL_SHADER(
-const float PI = 3.141592653589793;
-
-attribute vec4 a_pos_offset;
-attribute vec4 a_data;
-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; // 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;
-
-
-#ifndef HAS_UNIFORM_u_opacity
-uniform lowp float a_opacity_t;
-attribute lowp vec2 a_opacity;
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-uniform mat4 u_matrix;
-uniform mat4 u_label_plane_matrix;
-uniform mat4 u_gl_coord_matrix;
-
-uniform bool u_is_text;
-uniform bool u_pitch_with_map;
-
-uniform vec2 u_texsize;
-
-varying vec2 v_tex;
-varying float v_fade_opacity;
-
-void main() {
-
-#ifndef HAS_UNIFORM_u_opacity
- opacity = unpack_mix_vec2(a_opacity, a_opacity_t);
-#else
- lowp float opacity = u_opacity;
-#endif
-
-
- 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;
-
- 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[0], a_size[1], u_size_t) / 10.0;
- } else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {
- size = a_size[0] / 10.0;
- } else if (!u_is_size_zoom_constant && u_is_size_feature_constant) {
- size = u_size;
- } else {
- size = u_size;
- }
-
- vec4 projectedPoint = u_matrix * vec4(a_pos, 0, 1);
- 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 = u_matrix * vec4(a_pos + vec2(1, 0), 0, 1);
-
- 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 = u_label_plane_matrix * vec4(a_projected_pos.xy, 0.0, 1.0);
- gl_Position = u_gl_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 32.0 * fontScale), 0.0, 1.0);
-
- 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;
- v_fade_opacity = max(0.0, min(1.0, fade_opacity[0] + fade_change));
-}
-
-)MBGL_SHADER";
-const char* symbol_icon::fragmentSource = R"MBGL_SHADER(
-uniform sampler2D u_texture;
-
-
-#ifndef HAS_UNIFORM_u_opacity
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-varying vec2 v_tex;
-varying float v_fade_opacity;
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_opacity
- lowp float opacity = u_opacity;
-#endif
-
-
- lowp float alpha = opacity * v_fade_opacity;
- gl_FragColor = texture2D(u_texture, v_tex) * alpha;
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* symbol_icon::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0xad, 0x57, 0x4b, 0x8f, 0xdb, 0x36,
+ 0x10, 0xbe, 0xfb, 0x57, 0x4c, 0x10, 0x20, 0x90,
+ 0xbc, 0x7e, 0xdb, 0x9b, 0x76, 0x63, 0x6c, 0x17,
+ 0xbd, 0x14, 0xcd, 0x21, 0xad, 0xd1, 0x45, 0x4f,
+ 0x8b, 0x80, 0xa0, 0x25, 0xca, 0x66, 0x2b, 0x89,
+ 0x82, 0x44, 0xf9, 0xb1, 0x45, 0xfe, 0x7b, 0x87,
+ 0xa4, 0x4c, 0x51, 0x92, 0xe5, 0x6c, 0x81, 0xfa,
+ 0x20, 0xcb, 0xe4, 0xbc, 0xe7, 0x9b, 0x8f, 0x74,
+ 0x20, 0xd2, 0x42, 0x42, 0x14, 0x0b, 0x2a, 0x61,
+ 0xf3, 0x19, 0x1e, 0x61, 0x39, 0x99, 0xaf, 0xe6,
+ 0xf7, 0x0f, 0x8b, 0x8f, 0xf7, 0xcb, 0xfb, 0x1f,
+ 0x1f, 0x7e, 0x78, 0x58, 0xae, 0x07, 0x03, 0x2a,
+ 0x65, 0xce, 0xb7, 0xa5, 0x64, 0x70, 0x60, 0xc1,
+ 0x0a, 0x28, 0xc9, 0x44, 0x41, 0x44, 0x14, 0x15,
+ 0x4c, 0xae, 0xbb, 0x9b, 0x21, 0x95, 0xb4, 0xb5,
+ 0xbc, 0x54, 0x3a, 0xb9, 0xf8, 0x8b, 0x05, 0x92,
+ 0x85, 0x4a, 0xdb, 0xdd, 0x37, 0xce, 0x29, 0x89,
+ 0x68, 0xc8, 0x88, 0xc8, 0x68, 0xc0, 0xe5, 0x19,
+ 0x9d, 0x96, 0x29, 0x8f, 0x44, 0x9e, 0xc0, 0x56,
+ 0x88, 0x18, 0x4a, 0xc2, 0x0b, 0x52, 0xf0, 0x57,
+ 0x46, 0x5e, 0x85, 0x48, 0x48, 0xa0, 0xa2, 0xa6,
+ 0x29, 0x7a, 0xef, 0x91, 0x8a, 0x18, 0x95, 0x65,
+ 0xce, 0xae, 0x08, 0xee, 0xf9, 0x6e, 0x9f, 0x55,
+ 0x3e, 0x4b, 0x23, 0x2c, 0xd7, 0x30, 0x9d, 0x42,
+ 0x59, 0xb0, 0x10, 0xa4, 0x00, 0x9e, 0x4a, 0x96,
+ 0x67, 0x22, 0xa6, 0x18, 0xda, 0x96, 0xc9, 0x23,
+ 0x63, 0x29, 0x28, 0xa7, 0x50, 0x48, 0x91, 0x15,
+ 0x70, 0xdc, 0xe3, 0x6f, 0xa5, 0x06, 0xbc, 0x00,
+ 0x0a, 0x81, 0x48, 0x30, 0x1d, 0xae, 0xd2, 0x28,
+ 0xd3, 0x40, 0x72, 0x91, 0xde, 0xf0, 0x54, 0xfb,
+ 0x69, 0x58, 0xd9, 0x0a, 0xb9, 0x37, 0x2e, 0x68,
+ 0x1a, 0x42, 0x15, 0x3a, 0x5c, 0x42, 0xef, 0xb1,
+ 0x17, 0xd0, 0x84, 0xe5, 0x94, 0x48, 0x41, 0x02,
+ 0xa6, 0x22, 0x26, 0x21, 0x57, 0xe2, 0x01, 0xeb,
+ 0x4b, 0x35, 0xe3, 0x32, 0xd8, 0x77, 0x0a, 0x96,
+ 0x0b, 0x89, 0x89, 0x92, 0xe2, 0x9c, 0x6c, 0x45,
+ 0xdc, 0xa7, 0x4a, 0x8b, 0x0c, 0x3b, 0x47, 0x72,
+ 0x8a, 0xf9, 0xd5, 0x32, 0x97, 0x5d, 0xdd, 0xb7,
+ 0x60, 0x4f, 0xd3, 0x1d, 0xfa, 0x1e, 0x0c, 0xde,
+ 0xf3, 0x28, 0x0d, 0x59, 0x04, 0xbf, 0xfe, 0xfc,
+ 0x4c, 0xfe, 0xfc, 0xed, 0xf3, 0x2f, 0xbf, 0xff,
+ 0xf1, 0x85, 0x94, 0x97, 0xbe, 0x5a, 0xe5, 0x58,
+ 0x1c, 0x33, 0xdb, 0xf9, 0x6a, 0x93, 0x34, 0xd0,
+ 0xa4, 0x25, 0x10, 0x3b, 0x8b, 0x5a, 0x60, 0x3d,
+ 0x38, 0xd0, 0xfc, 0xcc, 0xd3, 0x9d, 0xab, 0x6e,
+ 0xf7, 0xde, 0xb3, 0xb8, 0x60, 0xd7, 0x1c, 0x94,
+ 0xc4, 0x91, 0x49, 0x43, 0x1e, 0x0d, 0x6a, 0x74,
+ 0x25, 0x54, 0xae, 0x50, 0x00, 0xbf, 0x72, 0x7e,
+ 0x5a, 0xb7, 0x97, 0x63, 0xba, 0x65, 0x31, 0xc9,
+ 0x62, 0x9a, 0xb2, 0x3e, 0x91, 0x5d, 0x8c, 0x20,
+ 0x13, 0x79, 0x68, 0xf7, 0xaf, 0x40, 0x52, 0xb2,
+ 0x53, 0x17, 0xaa, 0xba, 0x1f, 0xe4, 0xc8, 0xe5,
+ 0x1e, 0x55, 0x33, 0x47, 0x4f, 0xe7, 0x5c, 0x2a,
+ 0x25, 0x8d, 0x99, 0x81, 0x4d, 0x5a, 0x6f, 0x1c,
+ 0xd4, 0x46, 0x5d, 0x08, 0x93, 0xe1, 0xa1, 0x3d,
+ 0x3c, 0x07, 0xc1, 0x43, 0x8c, 0x90, 0xa7, 0x9e,
+ 0x0f, 0xff, 0x0c, 0x00, 0x3f, 0xdf, 0xe9, 0x8b,
+ 0x12, 0xa9, 0xde, 0x91, 0x04, 0xca, 0x14, 0x5f,
+ 0xff, 0x26, 0x09, 0x3f, 0x11, 0xe5, 0xd4, 0xb3,
+ 0x1d, 0x18, 0xb9, 0xdd, 0xf2, 0x2f, 0x35, 0x57,
+ 0xca, 0xdd, 0x8e, 0x28, 0x3b, 0x57, 0x2a, 0xaf,
+ 0x84, 0xab, 0xb6, 0xe2, 0xe4, 0xa0, 0x90, 0x4b,
+ 0x27, 0x93, 0x13, 0x8a, 0x3a, 0x12, 0x66, 0xb5,
+ 0x2d, 0xf4, 0x7a, 0x5c, 0x37, 0xec, 0x60, 0x45,
+ 0xb4, 0x88, 0x62, 0x9e, 0xb6, 0x05, 0x3d, 0x64,
+ 0x76, 0xd3, 0x6a, 0xba, 0x00, 0x2f, 0xd8, 0x2e,
+ 0xc1, 0x19, 0x22, 0x88, 0xe0, 0x58, 0xc9, 0x8e,
+ 0x5b, 0x64, 0xf5, 0xb2, 0xf8, 0x5a, 0x69, 0x55,
+ 0xf2, 0xba, 0x2d, 0xea, 0x37, 0x8f, 0xc0, 0x7b,
+ 0xd7, 0xc3, 0x4d, 0xf0, 0xe1, 0x03, 0xbc, 0xeb,
+ 0x67, 0xa4, 0x4b, 0x5f, 0xd4, 0xa7, 0x8a, 0x11,
+ 0xcb, 0xed, 0x99, 0x80, 0x5f, 0x66, 0x5f, 0x47,
+ 0x55, 0xec, 0x2f, 0x73, 0x7c, 0xbd, 0x10, 0x95,
+ 0x0f, 0x53, 0x98, 0xcf, 0x26, 0x33, 0xe3, 0xfd,
+ 0x1b, 0xa8, 0xea, 0xeb, 0x20, 0xfe, 0xb7, 0x18,
+ 0xac, 0xff, 0x3e, 0x4f, 0xb7, 0xd2, 0xfd, 0x4f,
+ 0x9e, 0x2a, 0x4a, 0x74, 0xed, 0xdf, 0x96, 0xb1,
+ 0x2d, 0x5f, 0x81, 0x6d, 0xcf, 0x46, 0x20, 0x5d,
+ 0x6b, 0x41, 0x33, 0x7e, 0x30, 0xd4, 0x02, 0x9e,
+ 0x86, 0xcb, 0x08, 0x66, 0x23, 0x98, 0xfb, 0xeb,
+ 0x4e, 0xc3, 0x6b, 0xee, 0x44, 0xc2, 0xdc, 0x8b,
+ 0x9a, 0x3b, 0xd1, 0x52, 0xd3, 0xf4, 0xe4, 0x68,
+ 0xb4, 0x91, 0xb7, 0x9f, 0x99, 0xe2, 0xe4, 0x44,
+ 0x21, 0xa5, 0xc0, 0x43, 0x02, 0x0c, 0x65, 0x92,
+ 0x22, 0x8c, 0x26, 0x07, 0x96, 0x23, 0x04, 0x3b,
+ 0x6e, 0x2e, 0x56, 0x0d, 0x71, 0xea, 0x28, 0x9b,
+ 0x43, 0x0f, 0x4f, 0x36, 0xe1, 0xfe, 0x90, 0xa6,
+ 0xb7, 0xc8, 0x1e, 0x3e, 0x59, 0x0b, 0xb7, 0xa4,
+ 0xa6, 0xfd, 0xf6, 0xbb, 0xd5, 0xc9, 0x58, 0xae,
+ 0xf9, 0x9e, 0x1f, 0xea, 0xc8, 0x83, 0x98, 0x26,
+ 0x99, 0x67, 0x7d, 0xa9, 0xcf, 0x6c, 0x72, 0x0f,
+ 0x77, 0xfa, 0x39, 0x6c, 0x65, 0x3a, 0x6a, 0xc9,
+ 0x61, 0x17, 0xb0, 0x7e, 0x9b, 0x9c, 0x1d, 0x74,
+ 0xed, 0x04, 0x96, 0x4b, 0xb5, 0x35, 0x84, 0x94,
+ 0xd1, 0x7c, 0x1c, 0x71, 0x16, 0x87, 0x55, 0x35,
+ 0x75, 0x61, 0x75, 0x8d, 0x58, 0x38, 0x55, 0x72,
+ 0x0a, 0x62, 0xea, 0x58, 0xe6, 0x31, 0x2b, 0x1a,
+ 0x56, 0x57, 0x93, 0x99, 0x5f, 0x0d, 0xa5, 0xc6,
+ 0xca, 0xf0, 0xb1, 0x1b, 0x77, 0x63, 0x68, 0x23,
+ 0x91, 0xca, 0xe7, 0x80, 0xc6, 0x06, 0x56, 0x15,
+ 0x29, 0xc3, 0x93, 0xd1, 0x9e, 0xc2, 0x02, 0x0d,
+ 0xc2, 0xa7, 0x6a, 0xb4, 0xbb, 0x0c, 0x61, 0x7a,
+ 0xad, 0x0f, 0x4b, 0x3c, 0xe2, 0xd1, 0x84, 0x1d,
+ 0x0d, 0x33, 0x7d, 0x8d, 0x63, 0xd4, 0x05, 0xfb,
+ 0x9b, 0x81, 0x63, 0xb1, 0x6d, 0x38, 0x6e, 0xf3,
+ 0x26, 0x84, 0x63, 0x03, 0x34, 0x3f, 0xcf, 0x11,
+ 0xea, 0xbe, 0x85, 0xbb, 0x6b, 0x0f, 0x29, 0xb0,
+ 0x0b, 0xea, 0xd3, 0x19, 0x33, 0xbe, 0x0e, 0x74,
+ 0xab, 0xb6, 0x45, 0xb5, 0x6b, 0xa1, 0x18, 0xe5,
+ 0xab, 0x3b, 0x47, 0xc7, 0x75, 0xb7, 0x62, 0x48,
+ 0xbf, 0xa9, 0xe7, 0x6d, 0x27, 0x67, 0x18, 0x03,
+ 0x9d, 0x9c, 0x7d, 0x0d, 0x6c, 0xf7, 0x66, 0x31,
+ 0x82, 0xed, 0xe4, 0xa4, 0x37, 0x4f, 0x7e, 0x63,
+ 0xe4, 0xdd, 0x4e, 0x68, 0x8e, 0x46, 0x56, 0x50,
+ 0x16, 0xf1, 0xe9, 0x35, 0xb9, 0xfb, 0xae, 0xed,
+ 0xf7, 0xca, 0xf0, 0x1b, 0x0b, 0x81, 0x3e, 0x7a,
+ 0xf0, 0xf9, 0x46, 0x0b, 0x58, 0xfc, 0x05, 0x5c,
+ 0xd6, 0x2e, 0xad, 0x78, 0xd4, 0xcb, 0x9e, 0xb5,
+ 0x38, 0x82, 0xf1, 0x1c, 0x61, 0x34, 0xac, 0xa3,
+ 0x1c, 0x75, 0x5f, 0x51, 0xce, 0x5f, 0x5f, 0xe3,
+ 0xb2, 0xea, 0x38, 0xbc, 0x76, 0xeb, 0x70, 0x9a,
+ 0xee, 0x4a, 0x63, 0x2f, 0x46, 0x66, 0xbe, 0xe6,
+ 0x7a, 0x1c, 0x94, 0x4d, 0xbc, 0x8f, 0x6c, 0xd4,
+ 0x85, 0xd4, 0x14, 0xbd, 0x73, 0x3f, 0xb9, 0x58,
+ 0x6a, 0xdb, 0x71, 0x01, 0xa1, 0x97, 0x8e, 0x58,
+ 0x8a, 0x76, 0xbe, 0x43, 0xf0, 0xec, 0x91, 0x3c,
+ 0x85, 0xe5, 0x42, 0xe7, 0x6a, 0x07, 0xcb, 0x6f,
+ 0xc4, 0x62, 0x12, 0xb4, 0x47, 0xb3, 0xfa, 0x9e,
+ 0xba, 0xb7, 0x1a, 0x0b, 0x34, 0xf7, 0xe6, 0x52,
+ 0x5f, 0x3d, 0xaa, 0x05, 0xaf, 0xf9, 0xb7, 0xa0,
+ 0xca, 0xb1, 0x9a, 0xe8, 0xfa, 0xde, 0x89, 0x7a,
+ 0xae, 0x18, 0x9e, 0x99, 0xf0, 0x93, 0xa6, 0xa6,
+ 0xa7, 0xe6, 0xfd, 0x14, 0x27, 0x7c, 0xdc, 0xba,
+ 0xb0, 0x9a, 0x30, 0x5b, 0x41, 0x24, 0xf4, 0xe4,
+ 0xe9, 0x5c, 0x12, 0x84, 0xd8, 0x5c, 0xbd, 0x34,
+ 0xcc, 0xe3, 0xe9, 0x78, 0xe7, 0xba, 0xf7, 0x31,
+ 0xae, 0x6f, 0x83, 0x7f, 0x01, 0xca, 0xcb, 0x70,
+ 0xe8
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* symbol_icon::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x75, 0x90, 0xcb, 0x6e, 0xc2, 0x30,
+ 0x10, 0x45, 0xf7, 0xf3, 0x15, 0x23, 0xb1, 0x49,
+ 0xaa, 0xaa, 0xa2, 0x51, 0x77, 0x51, 0x17, 0x88,
+ 0x80, 0x60, 0x51, 0x82, 0x42, 0x1f, 0x4b, 0xcb,
+ 0x22, 0x76, 0x6a, 0xc9, 0xb1, 0x23, 0x13, 0x9b,
+ 0xa2, 0xaa, 0xff, 0x5e, 0xbb, 0x24, 0x29, 0xe2,
+ 0xe1, 0xa5, 0x7d, 0xee, 0xf5, 0x99, 0xb1, 0x4a,
+ 0x70, 0x6d, 0x6a, 0xdc, 0xd1, 0xba, 0x91, 0xcc,
+ 0x24, 0x19, 0x5a, 0xd2, 0xb2, 0xaf, 0xd6, 0x1a,
+ 0x96, 0x02, 0xc0, 0x48, 0x70, 0x55, 0x32, 0x8e,
+ 0x8b, 0xc9, 0x86, 0xbc, 0xad, 0x96, 0xf3, 0xbc,
+ 0x78, 0x21, 0x96, 0xe8, 0x86, 0x6e, 0x45, 0x7b,
+ 0x00, 0x47, 0xcd, 0x41, 0xa8, 0x0a, 0xa5, 0xde,
+ 0x37, 0xc8, 0xa5, 0xa6, 0x2d, 0x76, 0x4f, 0x29,
+ 0x8c, 0x98, 0xdc, 0x31, 0xb0, 0x5d, 0xfd, 0x09,
+ 0x31, 0xc4, 0x03, 0xa3, 0x4a, 0xc1, 0xfd, 0x37,
+ 0x7d, 0x91, 0x63, 0xdb, 0x04, 0x5d, 0x10, 0x48,
+ 0x87, 0xbb, 0x63, 0xca, 0x11, 0x4e, 0x4b, 0xf6,
+ 0x1f, 0x05, 0xa7, 0x45, 0x89, 0x35, 0x15, 0x2a,
+ 0x8a, 0xf1, 0x1b, 0xd0, 0x9f, 0x20, 0x7b, 0xdb,
+ 0x35, 0x10, 0x97, 0x9e, 0xf8, 0x7c, 0xd5, 0xe7,
+ 0x0c, 0xa6, 0xb2, 0xf9, 0xa4, 0x1e, 0xed, 0x43,
+ 0x77, 0x17, 0x3a, 0x21, 0x50, 0x49, 0x32, 0x37,
+ 0xb4, 0x9a, 0x6a, 0xa9, 0x8d, 0x87, 0xbb, 0x2d,
+ 0x26, 0x59, 0x34, 0x6c, 0xf4, 0xfe, 0x38, 0x5b,
+ 0xec, 0x0b, 0xfe, 0x2a, 0x53, 0xe8, 0x9d, 0xf3,
+ 0xf7, 0x59, 0x91, 0x15, 0x93, 0x0f, 0xb2, 0x5c,
+ 0x6d, 0xd6, 0xb3, 0xe9, 0x6b, 0x5e, 0x5c, 0xab,
+ 0xf4, 0xeb, 0x79, 0x8a, 0x1e, 0x1f, 0xc6, 0xf1,
+ 0xa0, 0xfa, 0x03, 0xbf, 0x04, 0x34, 0x94, 0x99
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl
diff --git a/src/mbgl/shaders/symbol_sdf.cpp b/src/mbgl/shaders/symbol_sdf.cpp
index b584c00315..b58f6ef2ba 100644
--- a/src/mbgl/shaders/symbol_sdf.cpp
+++ b/src/mbgl/shaders/symbol_sdf.cpp
@@ -1,304 +1,328 @@
// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.
#include <mbgl/shaders/symbol_sdf.hpp>
+#include <mbgl/util/compression.hpp>
+
+#include <cstdint>
namespace mbgl {
namespace shaders {
const char* symbol_sdf::name = "symbol_sdf";
-const char* symbol_sdf::vertexSource = R"MBGL_SHADER(
-const float PI = 3.141592653589793;
-
-attribute vec4 a_pos_offset;
-attribute vec4 a_data;
-attribute vec3 a_projected_pos;
-attribute float a_fade_opacity;
-
-// contents of a_size vary based on the type of property value
-// used for {text,icon}-size.
-// For constants, a_size is disabled.
-// For source functions, we bind only one value per vertex: the value of {text,icon}-size evaluated for the current feature.
-// For composite functions:
-// [ text-size(lowerZoomStop, feature),
-// text-size(upperZoomStop, feature) ]
-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
-
-
-#ifndef HAS_UNIFORM_u_fill_color
-uniform lowp float a_fill_color_t;
-attribute highp vec4 a_fill_color;
-varying highp vec4 fill_color;
-#else
-uniform highp vec4 u_fill_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_halo_color
-uniform lowp float a_halo_color_t;
-attribute highp vec4 a_halo_color;
-varying highp vec4 halo_color;
-#else
-uniform highp vec4 u_halo_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-uniform lowp float a_opacity_t;
-attribute lowp vec2 a_opacity;
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_halo_width
-uniform lowp float a_halo_width_t;
-attribute lowp vec2 a_halo_width;
-varying lowp float halo_width;
-#else
-uniform lowp float u_halo_width;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_halo_blur
-uniform lowp float a_halo_blur_t;
-attribute lowp vec2 a_halo_blur;
-varying lowp float halo_blur;
-#else
-uniform lowp float u_halo_blur;
-#endif
-
-
-uniform mat4 u_matrix;
-uniform mat4 u_label_plane_matrix;
-uniform mat4 u_gl_coord_matrix;
-
-uniform bool u_is_text;
-uniform bool u_pitch_with_map;
-uniform highp float u_pitch;
-uniform bool u_rotate_symbol;
-uniform highp float u_aspect_ratio;
-uniform highp float u_camera_to_center_distance;
-uniform float u_fade_change;
-
-uniform vec2 u_texsize;
-
-varying vec2 v_data0;
-varying vec3 v_data1;
-
-void main() {
-
-#ifndef HAS_UNIFORM_u_fill_color
- fill_color = unpack_mix_vec4(a_fill_color, a_fill_color_t);
-#else
- highp vec4 fill_color = u_fill_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_halo_color
- halo_color = unpack_mix_vec4(a_halo_color, a_halo_color_t);
-#else
- highp vec4 halo_color = u_halo_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
- opacity = unpack_mix_vec2(a_opacity, a_opacity_t);
-#else
- lowp float opacity = u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_halo_width
- halo_width = unpack_mix_vec2(a_halo_width, a_halo_width_t);
-#else
- lowp float halo_width = u_halo_width;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_halo_blur
- halo_blur = unpack_mix_vec2(a_halo_blur, a_halo_blur_t);
-#else
- lowp float halo_blur = u_halo_blur;
-#endif
-
-
- 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;
-
- 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[0], a_size[1], u_size_t) / 10.0;
- } else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {
- size = a_size[0] / 10.0;
- } else if (!u_is_size_zoom_constant && u_is_size_feature_constant) {
- size = u_size;
- } else {
- size = u_size;
- }
-
- vec4 projectedPoint = u_matrix * vec4(a_pos, 0, 1);
- highp float camera_to_anchor_distance = projectedPoint.w;
- // If the label is pitched with the map, layout is done in pitched space,
- // which makes labels in the distance smaller relative to viewport space.
- // We counteract part of that effect by multiplying by the perspective ratio.
- // If the label isn't pitched with the map, we do layout in viewport space,
- // which makes labels in the distance larger relative to the features around
- // them. We counteract part of that effect by dividing by the perspective ratio.
- 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) {
- // Point labels with 'rotation-alignment: map' are horizontal with respect to tile units
- // To figure out that angle in projected space, we draw a short horizontal line in tile
- // space, project it, and measure its angle in projected space.
- vec4 offsetProjectedPoint = u_matrix * vec4(a_pos + vec2(1, 0), 0, 1);
-
- 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 = u_label_plane_matrix * vec4(a_projected_pos.xy, 0.0, 1.0);
- gl_Position = u_gl_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 32.0 * fontScale), 0.0, 1.0);
- float gamma_scale = gl_Position.w;
-
- vec2 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 interpolated_fade_opacity = max(0.0, min(1.0, fade_opacity[0] + fade_change));
-
- v_data0 = vec2(tex.x, tex.y);
- v_data1 = vec3(gamma_scale, size, interpolated_fade_opacity);
-}
-
-)MBGL_SHADER";
-const char* symbol_sdf::fragmentSource = R"MBGL_SHADER(
-#define SDF_PX 8.0
-#define EDGE_GAMMA 0.105/DEVICE_PIXEL_RATIO
-
-uniform bool u_is_halo;
-
-#ifndef HAS_UNIFORM_u_fill_color
-varying highp vec4 fill_color;
-#else
-uniform highp vec4 u_fill_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_halo_color
-varying highp vec4 halo_color;
-#else
-uniform highp vec4 u_halo_color;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_opacity
-varying lowp float opacity;
-#else
-uniform lowp float u_opacity;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_halo_width
-varying lowp float halo_width;
-#else
-uniform lowp float u_halo_width;
-#endif
-
-
-#ifndef HAS_UNIFORM_u_halo_blur
-varying lowp float halo_blur;
-#else
-uniform lowp float u_halo_blur;
-#endif
-
-
-uniform sampler2D u_texture;
-uniform highp float u_gamma_scale;
-uniform bool u_is_text;
-
-varying vec2 v_data0;
-varying vec3 v_data1;
-
-void main() {
-
-#ifdef HAS_UNIFORM_u_fill_color
- highp vec4 fill_color = u_fill_color;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_halo_color
- highp vec4 halo_color = u_halo_color;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_opacity
- lowp float opacity = u_opacity;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_halo_width
- lowp float halo_width = u_halo_width;
-#endif
-
-
-#ifdef HAS_UNIFORM_u_halo_blur
- lowp float halo_blur = u_halo_blur;
-#endif
-
-
- vec2 tex = v_data0.xy;
- float gamma_scale = v_data1.x;
- float size = v_data1.y;
- float fade_opacity = v_data1[2];
-
- float fontScale = u_is_text ? size / 24.0 : size;
-
- lowp vec4 color = fill_color;
- highp float gamma = EDGE_GAMMA / (fontScale * u_gamma_scale);
- lowp float buff = (256.0 - 64.0) / 256.0;
- if (u_is_halo) {
- color = halo_color;
- gamma = (halo_blur * 1.19 / SDF_PX + EDGE_GAMMA) / (fontScale * u_gamma_scale);
- buff = (6.0 - halo_width / fontScale) / SDF_PX;
- }
-
- lowp float dist = texture2D(u_texture, tex).a;
- highp float gamma_scaled = gamma * gamma_scale;
- highp float alpha = smoothstep(buff - gamma_scaled, buff + gamma_scaled, dist);
-
- gl_FragColor = color * (alpha * opacity * fade_opacity);
-
-#ifdef OVERDRAW_INSPECTOR
- gl_FragColor = vec4(1.0);
-#endif
-}
-
-)MBGL_SHADER";
+const char* symbol_sdf::vertexSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0xad, 0x58, 0x4d, 0x8f, 0xdb, 0x36,
+ 0x10, 0xbd, 0xfb, 0x57, 0x4c, 0x10, 0x20, 0xb1,
+ 0x37, 0x5a, 0x79, 0xbd, 0x1f, 0x6d, 0xb3, 0x46,
+ 0x1a, 0xf4, 0x52, 0x34, 0x87, 0xb6, 0x8b, 0xa6,
+ 0x45, 0x81, 0x06, 0x81, 0x40, 0x4b, 0x94, 0xcd,
+ 0x46, 0x12, 0x05, 0x89, 0x5a, 0xdb, 0x1b, 0xe4,
+ 0xbf, 0x77, 0x86, 0x94, 0x28, 0x4a, 0x96, 0xe4,
+ 0x04, 0xe8, 0x1e, 0xbc, 0x96, 0xe6, 0x71, 0xf8,
+ 0x86, 0x1c, 0xbe, 0x19, 0x3a, 0x94, 0x59, 0xa9,
+ 0x20, 0x4e, 0x24, 0x53, 0xf0, 0xf0, 0x0e, 0xde,
+ 0xc0, 0x8d, 0xbf, 0xba, 0x5d, 0xdd, 0xbd, 0xbe,
+ 0xfe, 0xee, 0xee, 0xe6, 0xee, 0x87, 0xd7, 0xdf,
+ 0xbf, 0xbe, 0x59, 0xcf, 0x66, 0x4c, 0xa9, 0x42,
+ 0x6c, 0x2a, 0xc5, 0xe1, 0x91, 0x87, 0xb7, 0xc0,
+ 0x82, 0x5c, 0x96, 0x81, 0x8c, 0xe3, 0x92, 0xab,
+ 0xf5, 0xa9, 0x31, 0x62, 0x8a, 0xf5, 0x5e, 0xdf,
+ 0xd0, 0x98, 0x42, 0xfe, 0xcb, 0x43, 0xc5, 0x23,
+ 0x1a, 0xed, 0xda, 0xcd, 0xe4, 0x2c, 0x88, 0x59,
+ 0xc4, 0x03, 0x99, 0xb3, 0x50, 0xa8, 0x23, 0x4e,
+ 0xba, 0x5c, 0x42, 0x28, 0x33, 0xc5, 0x33, 0x55,
+ 0x82, 0x8c, 0xd1, 0x5e, 0x8a, 0x27, 0x74, 0xc6,
+ 0x8a, 0x23, 0x6c, 0x58, 0xc9, 0x23, 0x90, 0x19,
+ 0xa8, 0x1d, 0x07, 0x75, 0xcc, 0x39, 0x01, 0xd0,
+ 0x7f, 0xce, 0x0b, 0x75, 0x44, 0x48, 0x52, 0x71,
+ 0x1a, 0x5e, 0x11, 0x2a, 0x96, 0x05, 0x7c, 0x56,
+ 0xfc, 0xa0, 0x3c, 0x81, 0xee, 0xbe, 0x5c, 0x92,
+ 0x17, 0x9f, 0xac, 0x3f, 0xa3, 0x21, 0xa4, 0xe8,
+ 0x19, 0xce, 0xe0, 0x35, 0xfe, 0x45, 0x09, 0x91,
+ 0x28, 0xd9, 0x26, 0xe1, 0x91, 0x45, 0x95, 0xb2,
+ 0x2a, 0x42, 0xe4, 0x59, 0x65, 0xa1, 0x12, 0x38,
+ 0xc2, 0x83, 0x3d, 0x87, 0x8d, 0xc8, 0x88, 0x42,
+ 0x72, 0xc4, 0x0f, 0x6e, 0xe6, 0x04, 0x9c, 0x1f,
+ 0xa3, 0x2d, 0x70, 0xb6, 0x7b, 0x4d, 0xcd, 0xbc,
+ 0x45, 0x6e, 0x7d, 0x02, 0xc0, 0xc9, 0xc4, 0x54,
+ 0xcd, 0x8f, 0xb0, 0x61, 0x55, 0x14, 0x18, 0x2b,
+ 0xc4, 0x9c, 0xa9, 0xaa, 0x70, 0x29, 0xa6, 0xb8,
+ 0x5e, 0x42, 0x39, 0xf3, 0xdf, 0x93, 0xed, 0x03,
+ 0x90, 0x4f, 0xed, 0x6d, 0x9e, 0xc8, 0x3d, 0x2f,
+ 0xfe, 0x91, 0x32, 0x7d, 0xaf, 0x64, 0xee, 0x35,
+ 0x2e, 0x16, 0x1e, 0xe1, 0xc0, 0xc1, 0x55, 0x79,
+ 0x3e, 0x84, 0x83, 0x8f, 0xb3, 0x2a, 0x13, 0x48,
+ 0x24, 0x85, 0x8d, 0x94, 0x09, 0x54, 0x81, 0x28,
+ 0xf5, 0x6a, 0x04, 0x4f, 0x88, 0x0d, 0x9a, 0x45,
+ 0x5a, 0x8f, 0xa1, 0x6a, 0x3f, 0x03, 0xc0, 0x9d,
+ 0xd8, 0xee, 0xf2, 0x7a, 0x83, 0x2b, 0x03, 0x56,
+ 0x6b, 0x68, 0xb6, 0x46, 0x49, 0x10, 0xb8, 0xc1,
+ 0x45, 0x2e, 0x13, 0x5c, 0x0a, 0xd8, 0x70, 0xb5,
+ 0xe7, 0x3c, 0x03, 0x9a, 0x14, 0x4a, 0x64, 0x58,
+ 0xc2, 0x7e, 0x87, 0xcf, 0xcd, 0xbe, 0xb0, 0x81,
+ 0xb5, 0x98, 0x98, 0xa9, 0x9d, 0xa7, 0xe3, 0x65,
+ 0x23, 0xd5, 0xce, 0x4c, 0xc1, 0x70, 0x03, 0x6b,
+ 0xea, 0x36, 0x11, 0x66, 0xb3, 0xd9, 0x73, 0x11,
+ 0x67, 0x11, 0x8f, 0xe1, 0x97, 0x9f, 0xde, 0x07,
+ 0x7f, 0xfd, 0xf6, 0xee, 0xe7, 0xdf, 0xff, 0xf8,
+ 0x35, 0xa8, 0x82, 0x58, 0x24, 0x09, 0x06, 0x98,
+ 0xc8, 0xc2, 0x4e, 0x89, 0xab, 0x9e, 0xb7, 0xc9,
+ 0x6b, 0xed, 0x41, 0xe7, 0x4c, 0x18, 0x5e, 0xf5,
+ 0xc9, 0x68, 0x41, 0xeb, 0x19, 0x25, 0xb2, 0xc8,
+ 0xb6, 0x2e, 0xc0, 0x35, 0x3f, 0xe7, 0x49, 0xc9,
+ 0x7b, 0xd1, 0x69, 0x50, 0x15, 0x74, 0x61, 0x59,
+ 0x24, 0xe2, 0x51, 0xd6, 0x3b, 0x96, 0xc8, 0x29,
+ 0xd6, 0xad, 0x7d, 0x82, 0x75, 0x0b, 0x1a, 0x64,
+ 0xed, 0x9a, 0x27, 0x58, 0x77, 0x61, 0x93, 0xac,
+ 0x6b, 0x0d, 0x18, 0xa6, 0x5c, 0x1b, 0xbb, 0x7c,
+ 0x35, 0x02, 0x27, 0xba, 0x6e, 0x01, 0x2d, 0x57,
+ 0x67, 0xb8, 0xb5, 0x75, 0x89, 0x3a, 0x88, 0x2a,
+ 0x70, 0x30, 0xe7, 0xd7, 0x76, 0x2f, 0x22, 0xb5,
+ 0x9b, 0x58, 0x5b, 0x6d, 0x1f, 0xe7, 0xda, 0x62,
+ 0x06, 0xe9, 0xba, 0xe6, 0x09, 0xc6, 0x5d, 0xd8,
+ 0x79, 0xd2, 0x9b, 0xa4, 0x9a, 0xca, 0x07, 0x32,
+ 0x9f, 0xa1, 0x4c, 0x90, 0x71, 0xc6, 0xc6, 0x7a,
+ 0x8e, 0x70, 0x83, 0xaa, 0xf9, 0x36, 0xc0, 0x94,
+ 0x29, 0x4a, 0x17, 0xfc, 0x57, 0x88, 0xc3, 0xba,
+ 0xff, 0x3a, 0x61, 0x1b, 0x9e, 0x04, 0x79, 0xc2,
+ 0x32, 0x3e, 0x06, 0xd9, 0xd2, 0xe1, 0x90, 0x45,
+ 0x64, 0xed, 0x03, 0xb2, 0x45, 0x92, 0x78, 0x22,
+ 0x67, 0xb9, 0x50, 0xe1, 0x0e, 0xd7, 0x11, 0x37,
+ 0x2c, 0x65, 0xf9, 0x98, 0x88, 0x69, 0xd4, 0xc9,
+ 0xd8, 0x42, 0x2a, 0x94, 0xb0, 0xa0, 0x3c, 0xa6,
+ 0x1b, 0x99, 0x8c, 0x0d, 0x65, 0x65, 0x8e, 0x05,
+ 0x30, 0x28, 0x18, 0x2a, 0xd7, 0x18, 0x26, 0x64,
+ 0x29, 0x2f, 0x58, 0xa0, 0xf0, 0xac, 0x70, 0xd2,
+ 0xc6, 0x00, 0xab, 0x11, 0x0a, 0x53, 0xc8, 0xdb,
+ 0x01, 0x0d, 0x54, 0xd7, 0xcb, 0x70, 0xc7, 0xb2,
+ 0x2d, 0x77, 0x82, 0xd4, 0xdb, 0x54, 0x51, 0x84,
+ 0x5a, 0x04, 0x67, 0x76, 0x97, 0xb4, 0xe1, 0x51,
+ 0x57, 0xe7, 0xab, 0xb5, 0xfb, 0xf6, 0xa6, 0x7e,
+ 0xbb, 0x22, 0xb0, 0x14, 0x11, 0x2e, 0xa4, 0xc8,
+ 0xe6, 0x0b, 0xf8, 0x3c, 0xc3, 0xe2, 0x01, 0xe7,
+ 0xf5, 0x90, 0x50, 0xed, 0x23, 0xb6, 0x10, 0x55,
+ 0x86, 0x47, 0xe8, 0x53, 0x90, 0x8a, 0x43, 0x40,
+ 0x87, 0x7f, 0xee, 0x0a, 0x9f, 0xd7, 0xd3, 0xca,
+ 0x45, 0x93, 0x28, 0xe4, 0x65, 0x50, 0x0b, 0xc9,
+ 0xe1, 0xa0, 0xe6, 0x4d, 0xb0, 0x73, 0x74, 0x4f,
+ 0xfb, 0xb5, 0x8f, 0x83, 0xec, 0x5a, 0xb3, 0xd7,
+ 0xd3, 0xc4, 0x31, 0x76, 0x5d, 0x87, 0x83, 0xda,
+ 0x36, 0xc1, 0xae, 0xd1, 0x37, 0x82, 0xd4, 0xdf,
+ 0x4f, 0x78, 0x5d, 0xcf, 0xad, 0x92, 0x79, 0xae,
+ 0xea, 0x75, 0x18, 0x9d, 0x2a, 0x9b, 0xa6, 0x73,
+ 0xa2, 0x60, 0xe7, 0x56, 0xca, 0xa8, 0x98, 0x5d,
+ 0x29, 0xfd, 0x38, 0xc8, 0xa8, 0x35, 0x7b, 0x3d,
+ 0x85, 0x1b, 0xe3, 0xd5, 0x75, 0x38, 0x28, 0x55,
+ 0xe7, 0xd8, 0x69, 0xb9, 0xb2, 0xe4, 0xe8, 0x69,
+ 0x9c, 0x1b, 0x59, 0xbd, 0xae, 0x90, 0x4d, 0x32,
+ 0x6b, 0xbc, 0x0d, 0x4a, 0x12, 0x0d, 0xa8, 0x55,
+ 0x0f, 0xdb, 0x0e, 0x84, 0xb9, 0x8d, 0xaf, 0x7f,
+ 0xc0, 0x05, 0x76, 0x10, 0xe6, 0x6d, 0x1f, 0xf4,
+ 0xb4, 0x5f, 0x77, 0xfc, 0xe0, 0xb1, 0xd4, 0x10,
+ 0x3a, 0x6f, 0x7d, 0x0f, 0xba, 0x43, 0xb1, 0x46,
+ 0x3b, 0xd2, 0xd5, 0x87, 0x92, 0x6f, 0x53, 0x94,
+ 0x85, 0x00, 0xcf, 0x7c, 0x42, 0xd8, 0xcb, 0x5e,
+ 0x5b, 0xfd, 0xe1, 0xfa, 0xa3, 0x71, 0x59, 0xc3,
+ 0x8d, 0x02, 0xd0, 0x0b, 0x11, 0xc3, 0xfc, 0xd9,
+ 0x48, 0x63, 0x07, 0x2f, 0x5e, 0xc0, 0xb3, 0xf1,
+ 0x76, 0xae, 0x51, 0x02, 0xfa, 0xab, 0x39, 0xe2,
+ 0xb2, 0xcf, 0x0d, 0xe1, 0x0f, 0x57, 0x1f, 0x9b,
+ 0xde, 0xf9, 0xc3, 0x0a, 0xbf, 0x36, 0x5d, 0xde,
+ 0x02, 0x96, 0xb0, 0xba, 0xf2, 0xaf, 0x0c, 0x9d,
+ 0x2f, 0x40, 0x3b, 0xa0, 0x49, 0xfc, 0x6f, 0x1c,
+ 0xec, 0xfc, 0x63, 0x33, 0x4d, 0x85, 0xfb, 0x4d,
+ 0x33, 0xd5, 0xfd, 0xa4, 0xeb, 0x7f, 0x1a, 0x63,
+ 0xb7, 0xfc, 0x16, 0xec, 0xf6, 0x3c, 0x48, 0xec,
+ 0x75, 0x35, 0xd0, 0xd4, 0x25, 0xb8, 0x80, 0x5a,
+ 0x7e, 0x70, 0xdf, 0x3c, 0xb8, 0xf2, 0x60, 0xb5,
+ 0x58, 0x9f, 0x6c, 0x78, 0x5b, 0x0e, 0xb0, 0x06,
+ 0xec, 0x64, 0x5b, 0x0e, 0xd0, 0x53, 0xd7, 0xb5,
+ 0xbf, 0x37, 0xa3, 0xb1, 0xe9, 0x7d, 0x17, 0xeb,
+ 0x1b, 0x85, 0xae, 0x95, 0xd4, 0xf2, 0xea, 0x92,
+ 0x45, 0x7d, 0x30, 0x96, 0x36, 0x6d, 0xc1, 0xf2,
+ 0xe6, 0xa1, 0xf9, 0x28, 0x2b, 0xa5, 0x2f, 0x3c,
+ 0x74, 0x83, 0x11, 0x99, 0xc5, 0x95, 0x78, 0xb4,
+ 0xb8, 0xd7, 0x78, 0xdb, 0xef, 0x44, 0xb8, 0xc3,
+ 0x21, 0x9f, 0x78, 0x69, 0x5c, 0x96, 0x84, 0x25,
+ 0x37, 0x96, 0x4b, 0x99, 0xb2, 0x24, 0xc1, 0xbb,
+ 0x4f, 0xc1, 0xb1, 0x91, 0x17, 0x8f, 0x9c, 0x3a,
+ 0xfb, 0x47, 0xc1, 0xf7, 0xb9, 0x2c, 0x94, 0xf1,
+ 0xe6, 0x37, 0xde, 0xfe, 0xa6, 0x5e, 0xbb, 0xa2,
+ 0xca, 0xc6, 0x42, 0x05, 0x39, 0x43, 0x80, 0x24,
+ 0xba, 0x18, 0x2b, 0x8f, 0x63, 0x0c, 0x07, 0x36,
+ 0x47, 0x48, 0xab, 0x44, 0x89, 0x3c, 0xd1, 0x05,
+ 0x0a, 0x1f, 0x69, 0x2e, 0xbc, 0xb8, 0xe8, 0xea,
+ 0x49, 0xde, 0x75, 0x01, 0xf5, 0x47, 0xa2, 0xcd,
+ 0x5e, 0xaa, 0x91, 0x80, 0xf1, 0xd2, 0x16, 0x49,
+ 0x1b, 0x76, 0xd6, 0x63, 0xf8, 0x2d, 0xf1, 0x26,
+ 0xac, 0xd8, 0xf6, 0xc2, 0x25, 0x7b, 0x9d, 0x4a,
+ 0x78, 0x53, 0x29, 0x30, 0xc4, 0xa8, 0x71, 0x88,
+ 0xa6, 0xd4, 0xff, 0xba, 0xc0, 0x23, 0xf1, 0x28,
+ 0xa2, 0xf3, 0x51, 0xbb, 0x19, 0xd2, 0x90, 0x32,
+ 0x6d, 0x85, 0x4e, 0xb0, 0x6e, 0x23, 0x03, 0x6f,
+ 0x6d, 0xae, 0x8e, 0x67, 0xd3, 0x72, 0xaa, 0xf5,
+ 0x80, 0x7b, 0xeb, 0x61, 0x0a, 0xb5, 0x1c, 0xf7,
+ 0x7f, 0x9a, 0xd8, 0x4e, 0x64, 0x96, 0x79, 0x98,
+ 0xb0, 0x34, 0x9f, 0xdb, 0xb9, 0xae, 0xfc, 0x3b,
+ 0x78, 0xa5, 0x3f, 0x2f, 0x7a, 0x51, 0x7a, 0x0e,
+ 0x06, 0x0f, 0x0e, 0xae, 0xf1, 0x43, 0xc1, 0x1f,
+ 0xcd, 0x2f, 0x05, 0x78, 0xff, 0xa6, 0x93, 0x18,
+ 0x41, 0xc6, 0x59, 0x71, 0x19, 0x0b, 0x9e, 0x60,
+ 0x42, 0xeb, 0xb6, 0xac, 0x74, 0x72, 0x7c, 0x49,
+ 0x38, 0x52, 0x05, 0xba, 0x86, 0x8a, 0x84, 0x97,
+ 0xd6, 0xe3, 0xad, 0x7f, 0xb5, 0xa8, 0x35, 0x53,
+ 0x1f, 0xed, 0x8b, 0x37, 0xa7, 0x5c, 0x6b, 0xbb,
+ 0x89, 0x24, 0x96, 0x99, 0x7a, 0x1f, 0xb2, 0xc4,
+ 0xa8, 0x40, 0xdd, 0x5c, 0xc2, 0x5b, 0x33, 0x7a,
+ 0x09, 0xd7, 0xe8, 0x10, 0xee, 0x5d, 0x29, 0xee,
+ 0x08, 0xba, 0x66, 0x66, 0xda, 0x47, 0xbc, 0xce,
+ 0xa2, 0x0b, 0xab, 0x64, 0x46, 0x2c, 0x3b, 0x8d,
+ 0xa5, 0xab, 0x4d, 0x14, 0xb4, 0x96, 0x94, 0x3a,
+ 0x47, 0x75, 0xae, 0xbf, 0x6c, 0x1c, 0x5d, 0xb2,
+ 0x44, 0x6c, 0x33, 0xaa, 0x15, 0xf7, 0x94, 0xfc,
+ 0x2f, 0x31, 0x25, 0xf1, 0x56, 0x27, 0x0b, 0xf1,
+ 0x84, 0x6c, 0x59, 0x62, 0xd0, 0x98, 0xaa, 0x14,
+ 0x96, 0x4e, 0x5f, 0x5c, 0x03, 0xac, 0xa9, 0x42,
+ 0x95, 0xee, 0x04, 0x7f, 0x4a, 0xec, 0xc3, 0xb6,
+ 0x74, 0x3f, 0xa6, 0x23, 0xa3, 0x73, 0xd5, 0x54,
+ 0x1e, 0x5a, 0xc8, 0x46, 0x7d, 0xea, 0xe3, 0xa3,
+ 0x8f, 0x57, 0xc1, 0xf6, 0x78, 0x4d, 0x2f, 0x77,
+ 0x74, 0xaa, 0x9c, 0xd9, 0x12, 0x61, 0x04, 0x86,
+ 0x66, 0x71, 0xfd, 0xd7, 0x23, 0x6b, 0x57, 0x20,
+ 0x94, 0xa7, 0x2f, 0xe5, 0x29, 0x67, 0x25, 0x4d,
+ 0x8a, 0x6c, 0x46, 0xe7, 0xf3, 0xad, 0x1f, 0x2d,
+ 0xb3, 0xa6, 0xdc, 0x3e, 0x7c, 0x95, 0xd8, 0x62,
+ 0x52, 0xe9, 0x96, 0x61, 0x85, 0xaa, 0xbb, 0xb0,
+ 0xca, 0xeb, 0xfa, 0xc3, 0x6a, 0x7c, 0xaa, 0xaf,
+ 0x87, 0x23, 0xee, 0xe6, 0xb0, 0xe6, 0xda, 0x61,
+ 0x1b, 0x1c, 0x36, 0x44, 0xc5, 0x0c, 0x1e, 0xb4,
+ 0xec, 0x9d, 0xa9, 0x4f, 0xb3, 0x01, 0x3b, 0x81,
+ 0x6c, 0x3e, 0xdf, 0xf8, 0x47, 0xb8, 0x04, 0xe6,
+ 0x1f, 0x17, 0xfa, 0xa0, 0xba, 0xf7, 0x08, 0x0f,
+ 0x36, 0xfe, 0x41, 0x1b, 0x0f, 0x8b, 0x4e, 0xf5,
+ 0x71, 0xb3, 0x4c, 0x2f, 0x22, 0x16, 0x28, 0xf2,
+ 0x88, 0x9f, 0xf3, 0x6e, 0x1b, 0xf1, 0xaa, 0x3f,
+ 0xef, 0x40, 0x1d, 0x32, 0x1e, 0x42, 0xdd, 0x05,
+ 0xe1, 0xe7, 0x57, 0x7a, 0xc0, 0xc5, 0xbf, 0x86,
+ 0xe6, 0x5d, 0xb3, 0x15, 0x6f, 0xf4, 0xeb, 0xb9,
+ 0xf5, 0xe8, 0xc1, 0xe5, 0x0a, 0x8f, 0xc8, 0x45,
+ 0xcb, 0xd2, 0x3b, 0xfd, 0x8a, 0xb8, 0xc5, 0x7a,
+ 0xa8, 0xac, 0xd6, 0x9d, 0xd9, 0xd0, 0xcd, 0xd0,
+ 0xd9, 0x74, 0x17, 0x8d, 0x7b, 0xe1, 0x19, 0xdd,
+ 0x58, 0xe9, 0xa3, 0x4e, 0x3e, 0xf1, 0xce, 0xf8,
+ 0x40, 0x3f, 0x2c, 0x99, 0x45, 0x3f, 0xb9, 0x43,
+ 0x36, 0x9e, 0xfa, 0x7e, 0xdc, 0x84, 0xd0, 0xaf,
+ 0xf6, 0xb8, 0x14, 0xfd, 0x78, 0x2f, 0x60, 0x6e,
+ 0xbb, 0xc3, 0x25, 0xdc, 0x5c, 0xeb, 0x58, 0xad,
+ 0x68, 0x2c, 0x4e, 0xb8, 0x98, 0x05, 0xdf, 0xb2,
+ 0x34, 0xc5, 0x0e, 0xa7, 0xd6, 0x15, 0x87, 0x9f,
+ 0xdf, 0xe9, 0x28, 0x9b, 0x7e, 0x92, 0xfe, 0x2f,
+ 0xdd, 0x6b, 0x9f, 0x45, 0xb8, 0xbf, 0xaa, 0xb6,
+ 0x7d, 0x73, 0xfd, 0x62, 0xde, 0xfd, 0xd5, 0xb5,
+ 0xc3, 0xc0, 0xb9, 0x5e, 0xe2, 0x38, 0x17, 0x86,
+ 0x8d, 0x1e, 0xfc, 0xa8, 0x85, 0xf9, 0x6d, 0xf7,
+ 0x1a, 0x8a, 0x3a, 0x77, 0xd9, 0xbb, 0x97, 0xb6,
+ 0xfe, 0x9c, 0x9f, 0xfa, 0xa2, 0xa0, 0xc7, 0x2a,
+ 0x65, 0x87, 0xb9, 0x5e, 0x86, 0x14, 0xb3, 0x73,
+ 0x45, 0x5f, 0x3a, 0xf3, 0x61, 0x8f, 0xf7, 0xca,
+ 0xe5, 0xb3, 0xb0, 0xb9, 0x60, 0xae, 0xb3, 0xe8,
+ 0x41, 0x9f, 0x68, 0x8c, 0xde, 0x3f, 0x78, 0xb4,
+ 0x28, 0x7e, 0x13, 0x4b, 0x7d, 0xb5, 0x35, 0x88,
+ 0x9b, 0xb9, 0xb3, 0xac, 0x9e, 0xd6, 0x64, 0x6f,
+ 0x9c, 0x17, 0x7a, 0xf8, 0x32, 0xfb, 0x0f, 0x8f,
+ 0x42, 0xd8, 0x87
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
+const char* symbol_sdf::fragmentSource = [] () {
+ static const uint8_t compressed[] = {
+ 0x78, 0xda, 0x8d, 0x55, 0x6b, 0x6f, 0xda, 0x30,
+ 0x14, 0xfd, 0x9e, 0x5f, 0x71, 0x25, 0xbe, 0x24,
+ 0x69, 0x1b, 0x1e, 0x6b, 0xab, 0x6d, 0xd1, 0x34,
+ 0x21, 0x08, 0x1d, 0x52, 0x29, 0x08, 0xba, 0xae,
+ 0xd2, 0x34, 0x59, 0x86, 0x24, 0x60, 0xc9, 0xc4,
+ 0x28, 0x0f, 0x4a, 0x37, 0xf5, 0xbf, 0xcf, 0xce,
+ 0xcb, 0x4e, 0x4a, 0xa0, 0xf9, 0x86, 0xef, 0xb9,
+ 0xe7, 0xdc, 0xc7, 0xb1, 0x69, 0xb9, 0x9e, 0x4f,
+ 0x02, 0x0f, 0x16, 0xc3, 0x11, 0x9a, 0x3d, 0xc3,
+ 0x67, 0xab, 0xa3, 0xb5, 0xf2, 0x23, 0x67, 0x78,
+ 0xe7, 0xa0, 0xbb, 0xfe, 0x64, 0xd2, 0x87, 0x8e,
+ 0xd5, 0xed, 0xdc, 0xb4, 0x87, 0xce, 0xd3, 0x78,
+ 0xe0, 0xa0, 0xd9, 0xf8, 0xd9, 0xb9, 0x47, 0xf3,
+ 0xfe, 0xe3, 0x78, 0xaa, 0x69, 0x49, 0x40, 0x7c,
+ 0x16, 0x6e, 0x61, 0xc9, 0x18, 0x85, 0x04, 0x91,
+ 0x08, 0x6d, 0x30, 0x65, 0xb6, 0xa6, 0xb5, 0x88,
+ 0x1f, 0x70, 0x22, 0xf8, 0xd1, 0x5f, 0xa0, 0x9f,
+ 0x0f, 0xe3, 0xd1, 0x74, 0x3e, 0x41, 0x09, 0xf2,
+ 0x09, 0xa5, 0x68, 0xc5, 0x28, 0x0b, 0xb5, 0x3d,
+ 0x0e, 0x5f, 0x49, 0xb0, 0x86, 0x0d, 0x59, 0x6f,
+ 0x76, 0xb0, 0xf7, 0x56, 0xd7, 0x20, 0xa3, 0xb6,
+ 0xd6, 0xf2, 0x68, 0xe4, 0x95, 0xf4, 0x0a, 0x48,
+ 0x25, 0x11, 0xb0, 0xc0, 0x25, 0xbe, 0xd6, 0xa4,
+ 0x27, 0x8a, 0x69, 0xd6, 0x93, 0xd1, 0x93, 0x7a,
+ 0x55, 0xd8, 0x49, 0x3d, 0xb6, 0xc3, 0x2b, 0x12,
+ 0xbf, 0x96, 0x62, 0x94, 0xbd, 0xec, 0xc0, 0xa7,
+ 0x0c, 0xc7, 0x90, 0x87, 0xea, 0x4a, 0x0a, 0xa2,
+ 0x4c, 0xff, 0x58, 0x5b, 0x2f, 0xc4, 0x8d, 0x37,
+ 0xc7, 0x94, 0x64, 0xf4, 0xa4, 0x58, 0x15, 0x76,
+ 0x5e, 0x6f, 0x49, 0x93, 0xb0, 0x51, 0x4e, 0x04,
+ 0xcf, 0xab, 0x15, 0xa8, 0x5c, 0xac, 0x00, 0x46,
+ 0x78, 0xbb, 0xa3, 0x5e, 0xd8, 0x1b, 0x72, 0x5c,
+ 0xec, 0x1d, 0xe2, 0x24, 0xf4, 0xec, 0xda, 0x2a,
+ 0x0a, 0x9a, 0x35, 0xde, 0x6e, 0x31, 0x8a, 0x56,
+ 0x98, 0x2a, 0x10, 0x69, 0x3e, 0x91, 0xcd, 0xcd,
+ 0x57, 0x54, 0xc9, 0x17, 0xd8, 0x83, 0x3d, 0x72,
+ 0x71, 0x8c, 0x3b, 0xb6, 0x7a, 0xfa, 0x29, 0x3f,
+ 0xed, 0x0a, 0x30, 0x23, 0x2e, 0x6c, 0x31, 0x09,
+ 0x74, 0x03, 0xfe, 0x69, 0xc0, 0x3f, 0x31, 0x85,
+ 0x93, 0xde, 0x15, 0xa0, 0xa3, 0xbe, 0x85, 0x6f,
+ 0x0d, 0xfe, 0x6c, 0xa6, 0x55, 0x2c, 0x5a, 0xa3,
+ 0x95, 0x91, 0x94, 0xf6, 0x98, 0x0d, 0x9b, 0x69,
+ 0x0b, 0x27, 0x0a, 0xc4, 0x7b, 0x17, 0xa6, 0x84,
+ 0xef, 0xdc, 0x76, 0xa6, 0xc8, 0xcc, 0x70, 0x35,
+ 0x42, 0x19, 0x91, 0x45, 0xd6, 0x4c, 0x75, 0x86,
+ 0x36, 0xf5, 0xd5, 0x31, 0x56, 0x11, 0x90, 0xa4,
+ 0x35, 0xef, 0x88, 0x84, 0x74, 0xbd, 0x7c, 0xe5,
+ 0x1c, 0x94, 0x2f, 0xd9, 0x3a, 0xf0, 0x76, 0x44,
+ 0x28, 0xa3, 0x51, 0xdc, 0x52, 0x62, 0xba, 0xd6,
+ 0x41, 0x85, 0x44, 0xe4, 0xaf, 0x1a, 0xab, 0xa4,
+ 0xfb, 0xd8, 0xf5, 0x90, 0x9c, 0x58, 0x8e, 0xf9,
+ 0xdd, 0xfb, 0x63, 0x6b, 0x2a, 0x8a, 0x05, 0xf1,
+ 0x22, 0x97, 0x28, 0x4d, 0x08, 0xdf, 0x33, 0xe6,
+ 0x36, 0xf4, 0xae, 0xad, 0x0e, 0x7c, 0x4d, 0x7f,
+ 0xe5, 0x69, 0x69, 0x9f, 0xe9, 0x86, 0x8b, 0xe5,
+ 0xaa, 0x8e, 0x91, 0x26, 0x50, 0x7a, 0xe0, 0x18,
+ 0xe5, 0x39, 0x6e, 0x83, 0x2e, 0x45, 0xcd, 0xea,
+ 0xad, 0x30, 0xec, 0xfa, 0x2c, 0x97, 0x89, 0xef,
+ 0xf3, 0x7c, 0xbd, 0x77, 0x73, 0xcb, 0x2b, 0xb9,
+ 0x82, 0x5b, 0x5e, 0x90, 0x21, 0x0a, 0x13, 0xbf,
+ 0x33, 0x34, 0xf1, 0x41, 0x2f, 0x1f, 0xef, 0xe2,
+ 0x16, 0x88, 0xaf, 0x28, 0x50, 0xf5, 0x5e, 0x11,
+ 0x2b, 0x0a, 0xd3, 0xe5, 0xb2, 0x4c, 0xe8, 0x5a,
+ 0xdd, 0x2f, 0x9c, 0x3b, 0xff, 0x3b, 0xb9, 0x50,
+ 0xaa, 0x36, 0x3e, 0x52, 0xb6, 0xf8, 0x8a, 0x7a,
+ 0xb3, 0x6a, 0x15, 0x7f, 0xb5, 0xe5, 0xa8, 0x8d,
+ 0x52, 0x23, 0xcb, 0x7b, 0xd3, 0xea, 0x5d, 0xbb,
+ 0x24, 0x8a, 0x39, 0x4b, 0xfe, 0x9c, 0xf4, 0x86,
+ 0x7a, 0xf9, 0xb4, 0x5c, 0x8a, 0x43, 0xc3, 0xc2,
+ 0x0d, 0xa3, 0xce, 0xea, 0x71, 0x79, 0x6e, 0xd6,
+ 0xa0, 0x09, 0x95, 0x37, 0xa7, 0x9e, 0x83, 0xe9,
+ 0x6e, 0x23, 0xa6, 0x10, 0x6d, 0x19, 0x8b, 0x37,
+ 0x51, 0xec, 0xed, 0xf4, 0xb4, 0x81, 0xab, 0x0a,
+ 0xdb, 0x65, 0xd6, 0xd5, 0x45, 0xed, 0x50, 0x14,
+ 0x69, 0xe4, 0xae, 0x58, 0x53, 0x34, 0x0a, 0xf1,
+ 0x7a, 0x90, 0x4f, 0x3c, 0x9b, 0xbc, 0x09, 0x7a,
+ 0x26, 0x60, 0x96, 0x37, 0xd7, 0xac, 0xd8, 0xd2,
+ 0xc8, 0xfe, 0x6a, 0xc5, 0xd5, 0x9a, 0x3e, 0x39,
+ 0xf3, 0xe1, 0xbc, 0xff, 0x0b, 0x8d, 0x1f, 0x16,
+ 0x33, 0x67, 0xf0, 0x38, 0x9d, 0x1f, 0xe3, 0x15,
+ 0xbe, 0xd3, 0xbb, 0xdc, 0x01, 0xe5, 0x5d, 0x7a,
+ 0xd3, 0xfe, 0x03, 0xa2, 0x37, 0x95, 0x61
+ };
+ static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed)));
+ return decompressed.c_str();
+}();
} // namespace shaders
} // namespace mbgl