diff options
Diffstat (limited to 'src/mbgl/shader')
28 files changed, 294 insertions, 205 deletions
diff --git a/src/mbgl/shader/circle_shader.cpp b/src/mbgl/shader/circle_shader.cpp index 2865769ee2..b19dbeba68 100644 --- a/src/mbgl/shader/circle_shader.cpp +++ b/src/mbgl/shader/circle_shader.cpp @@ -3,15 +3,18 @@ #include <mbgl/shader/circle.fragment.hpp> #include <mbgl/gl/gl.hpp> -#include <cstdio> +namespace mbgl { -using namespace mbgl; - -CircleShader::CircleShader(gl::ObjectStore& store) - : Shader("circle", shaders::circle::vertex, shaders::circle::fragment, store) { +CircleShader::CircleShader(gl::ObjectStore& store, Defines defines) + : Shader(shaders::circle::name, + shaders::circle::vertex, + shaders::circle::fragment, + store, defines) { } void CircleShader::bind(GLbyte* offset) { MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos)); MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 4, offset)); } + +} // namespace mbgl diff --git a/src/mbgl/shader/circle_shader.hpp b/src/mbgl/shader/circle_shader.hpp index cd22d4c9b1..c454fc1337 100644 --- a/src/mbgl/shader/circle_shader.hpp +++ b/src/mbgl/shader/circle_shader.hpp @@ -2,22 +2,24 @@ #include <mbgl/shader/shader.hpp> #include <mbgl/shader/uniform.hpp> +#include <mbgl/util/color.hpp> namespace mbgl { class CircleShader : public Shader { public: - CircleShader(gl::ObjectStore&); + CircleShader(gl::ObjectStore&, Defines defines = None); void bind(GLbyte *offset) final; UniformMatrix<4> u_matrix = {"u_matrix", *this}; Uniform<std::array<GLfloat, 2>> u_extrude_scale = {"u_extrude_scale", *this}; Uniform<GLfloat> u_devicepixelratio = {"u_devicepixelratio", *this}; - Uniform<std::array<GLfloat, 4>> u_color = {"u_color", *this}; + Uniform<Color> u_color = {"u_color", *this}; Uniform<GLfloat> u_radius = {"u_radius", *this}; Uniform<GLfloat> u_blur = {"u_blur", *this}; Uniform<GLfloat> u_opacity = {"u_opacity", *this}; + Uniform<GLint> u_scale_with_map = {"u_scale_with_map", *this}; }; } // namespace mbgl diff --git a/src/mbgl/shader/collision_box_shader.cpp b/src/mbgl/shader/collision_box_shader.cpp index cf4ff81e96..bfee89fac2 100644 --- a/src/mbgl/shader/collision_box_shader.cpp +++ b/src/mbgl/shader/collision_box_shader.cpp @@ -3,14 +3,13 @@ #include <mbgl/shader/collisionbox.fragment.hpp> #include <mbgl/gl/gl.hpp> -#include <cstdio> - -using namespace mbgl; +namespace mbgl { CollisionBoxShader::CollisionBoxShader(gl::ObjectStore& store) - : Shader("collisionbox", shaders::collisionbox::vertex, shaders::collisionbox::fragment, store) - , a_extrude(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_extrude"))) - , a_data(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data"))) { + : Shader(shaders::collisionbox::name, + shaders::collisionbox::vertex, + shaders::collisionbox::fragment, + store) { } void CollisionBoxShader::bind(GLbyte *offset) { @@ -24,5 +23,6 @@ void CollisionBoxShader::bind(GLbyte *offset) { MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data)); MBGL_CHECK_ERROR(glVertexAttribPointer(a_data, 2, GL_UNSIGNED_BYTE, false, stride, offset + 8)); - } + +} // namespace mbgl diff --git a/src/mbgl/shader/collision_box_shader.hpp b/src/mbgl/shader/collision_box_shader.hpp index a9b38a9849..bbd2611ce8 100644 --- a/src/mbgl/shader/collision_box_shader.hpp +++ b/src/mbgl/shader/collision_box_shader.hpp @@ -16,10 +16,6 @@ public: Uniform<GLfloat> u_scale = {"u_scale", *this}; Uniform<GLfloat> u_zoom = {"u_zoom", *this}; Uniform<GLfloat> u_maxzoom = {"u_maxzoom", *this}; - -protected: - GLint a_extrude = -1; - GLint a_data = -1; }; } // namespace mbgl diff --git a/src/mbgl/shader/icon_shader.cpp b/src/mbgl/shader/icon_shader.cpp index 7fb0335dc8..d91fbe2ec0 100644 --- a/src/mbgl/shader/icon_shader.cpp +++ b/src/mbgl/shader/icon_shader.cpp @@ -3,15 +3,13 @@ #include <mbgl/shader/icon.fragment.hpp> #include <mbgl/gl/gl.hpp> -#include <cstdio> +namespace mbgl { -using namespace mbgl; - -IconShader::IconShader(gl::ObjectStore& store) - : Shader("icon", shaders::icon::vertex, shaders::icon::fragment, store) - , a_offset(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_offset"))) - , a_data1(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data1"))) - , a_data2(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data2"))) { +IconShader::IconShader(gl::ObjectStore& store, Defines defines) + : Shader(shaders::icon::name, + shaders::icon::vertex, + shaders::icon::fragment, + store, defines) { } void IconShader::bind(GLbyte* offset) { @@ -29,3 +27,5 @@ void IconShader::bind(GLbyte* offset) { MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data2)); MBGL_CHECK_ERROR(glVertexAttribPointer(a_data2, 4, GL_UNSIGNED_BYTE, false, stride, offset + 12)); } + +} // namespace mbgl diff --git a/src/mbgl/shader/icon_shader.hpp b/src/mbgl/shader/icon_shader.hpp index b8cfcabb10..86c7b8ece0 100644 --- a/src/mbgl/shader/icon_shader.hpp +++ b/src/mbgl/shader/icon_shader.hpp @@ -7,7 +7,7 @@ namespace mbgl { class IconShader : public Shader { public: - IconShader(gl::ObjectStore&); + IconShader(gl::ObjectStore&, Defines defines = None); void bind(GLbyte *offset) final; @@ -16,14 +16,9 @@ public: Uniform<GLfloat> u_zoom = {"u_zoom", *this}; Uniform<GLfloat> u_opacity = {"u_opacity", *this}; Uniform<std::array<GLfloat, 2>> u_texsize = {"u_texsize", *this}; - Uniform<GLint> u_skewed = {"u_skewed", *this}; + Uniform<GLint> u_rotate_with_map = {"u_rotate_with_map", *this}; Uniform<GLint> u_texture = {"u_texture", *this}; Uniform<GLint> u_fadetexture = {"u_fadetexture", *this}; - -protected: - GLint a_offset = -1; - GLint a_data1 = -1; - GLint a_data2 = -1; }; } // namespace mbgl diff --git a/src/mbgl/shader/line_shader.cpp b/src/mbgl/shader/line_shader.cpp index f21384082f..8c3ad32d73 100644 --- a/src/mbgl/shader/line_shader.cpp +++ b/src/mbgl/shader/line_shader.cpp @@ -3,13 +3,13 @@ #include <mbgl/shader/line.fragment.hpp> #include <mbgl/gl/gl.hpp> -#include <cstdio> +namespace mbgl { -using namespace mbgl; - -LineShader::LineShader(gl::ObjectStore& store) - : Shader("line", shaders::line::vertex, shaders::line::fragment, store) - , a_data(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data"))) { +LineShader::LineShader(gl::ObjectStore& store, Defines defines) + : Shader(shaders::line::name, + shaders::line::vertex, + shaders::line::fragment, + store, defines) { } void LineShader::bind(GLbyte* offset) { @@ -19,3 +19,5 @@ void LineShader::bind(GLbyte* offset) { MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data)); MBGL_CHECK_ERROR(glVertexAttribPointer(a_data, 4, GL_UNSIGNED_BYTE, false, 8, offset + 4)); } + +} // namespace mbgl diff --git a/src/mbgl/shader/line_shader.hpp b/src/mbgl/shader/line_shader.hpp index e0d14094a6..a2cda56314 100644 --- a/src/mbgl/shader/line_shader.hpp +++ b/src/mbgl/shader/line_shader.hpp @@ -2,17 +2,18 @@ #include <mbgl/shader/shader.hpp> #include <mbgl/shader/uniform.hpp> +#include <mbgl/util/color.hpp> namespace mbgl { class LineShader : public Shader { public: - LineShader(gl::ObjectStore&); + LineShader(gl::ObjectStore&, Defines defines = None); void bind(GLbyte *offset) final; UniformMatrix<4> u_matrix = {"u_matrix", *this}; - Uniform<std::array<GLfloat, 4>> u_color = {"u_color", *this}; + Uniform<Color> u_color = {"u_color", *this}; Uniform<GLfloat> u_opacity = {"u_opacity", *this}; Uniform<GLfloat> u_ratio = {"u_ratio", *this}; Uniform<GLfloat> u_linewidth = {"u_linewidth", *this}; @@ -22,9 +23,6 @@ public: Uniform<GLfloat> u_extra = {"u_extra", *this}; Uniform<GLfloat> u_offset = {"u_offset", *this}; UniformMatrix<2> u_antialiasingmatrix = {"u_antialiasingmatrix", *this}; - -private: - GLint a_data = -1; }; diff --git a/src/mbgl/shader/linepattern_shader.cpp b/src/mbgl/shader/linepattern_shader.cpp index a9923233af..48375dec24 100644 --- a/src/mbgl/shader/linepattern_shader.cpp +++ b/src/mbgl/shader/linepattern_shader.cpp @@ -3,13 +3,13 @@ #include <mbgl/shader/linepattern.fragment.hpp> #include <mbgl/gl/gl.hpp> -#include <cstdio> +namespace mbgl { -using namespace mbgl; - -LinepatternShader::LinepatternShader(gl::ObjectStore& store) - : Shader("linepattern", shaders::linepattern::vertex, shaders::linepattern::fragment, store) - , a_data(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data"))) { +LinepatternShader::LinepatternShader(gl::ObjectStore& store, Defines defines) + : Shader(shaders::linepattern::name, + shaders::linepattern::vertex, + shaders::linepattern::fragment, + store, defines) { } void LinepatternShader::bind(GLbyte* offset) { @@ -19,3 +19,5 @@ void LinepatternShader::bind(GLbyte* offset) { MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data)); MBGL_CHECK_ERROR(glVertexAttribPointer(a_data, 4, GL_UNSIGNED_BYTE, false, 8, offset + 4)); } + +} // namespace mbgl diff --git a/src/mbgl/shader/linepattern_shader.hpp b/src/mbgl/shader/linepattern_shader.hpp index c34c1a5292..6c44716d10 100644 --- a/src/mbgl/shader/linepattern_shader.hpp +++ b/src/mbgl/shader/linepattern_shader.hpp @@ -7,7 +7,7 @@ namespace mbgl { class LinepatternShader : public Shader { public: - LinepatternShader(gl::ObjectStore&); + LinepatternShader(gl::ObjectStore&, Defines defines = None); void bind(GLbyte *offset) final; @@ -30,8 +30,6 @@ public: Uniform<GLfloat> u_offset = {"u_offset", *this}; Uniform<GLint> u_image = {"u_image", *this}; UniformMatrix<2> u_antialiasingmatrix = {"u_antialiasingmatrix", *this}; - -private: - GLint a_data = -1; }; + } // namespace mbgl diff --git a/src/mbgl/shader/linesdf_shader.cpp b/src/mbgl/shader/linesdf_shader.cpp index b316d2562d..8b2e983e0d 100644 --- a/src/mbgl/shader/linesdf_shader.cpp +++ b/src/mbgl/shader/linesdf_shader.cpp @@ -3,13 +3,13 @@ #include <mbgl/shader/linesdfpattern.fragment.hpp> #include <mbgl/gl/gl.hpp> -#include <cstdio> +namespace mbgl { -using namespace mbgl; - -LineSDFShader::LineSDFShader(gl::ObjectStore& store) - : Shader("linesdfpattern", shaders::linesdfpattern::vertex, shaders::linesdfpattern::fragment, store) - , a_data(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data"))) { +LineSDFShader::LineSDFShader(gl::ObjectStore& store, Defines defines) + : Shader(shaders::linesdfpattern::name, + shaders::linesdfpattern::vertex, + shaders::linesdfpattern::fragment, + store, defines) { } void LineSDFShader::bind(GLbyte* offset) { @@ -19,3 +19,5 @@ void LineSDFShader::bind(GLbyte* offset) { MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data)); MBGL_CHECK_ERROR(glVertexAttribPointer(a_data, 4, GL_UNSIGNED_BYTE, false, 8, offset + 4)); } + +} // namespace mbgl diff --git a/src/mbgl/shader/linesdf_shader.hpp b/src/mbgl/shader/linesdf_shader.hpp index 8791f243c0..ce1fe4d17c 100644 --- a/src/mbgl/shader/linesdf_shader.hpp +++ b/src/mbgl/shader/linesdf_shader.hpp @@ -2,17 +2,18 @@ #include <mbgl/shader/shader.hpp> #include <mbgl/shader/uniform.hpp> +#include <mbgl/util/color.hpp> namespace mbgl { class LineSDFShader : public Shader { public: - LineSDFShader(gl::ObjectStore&); + LineSDFShader(gl::ObjectStore&, Defines defines = None); void bind(GLbyte *offset) final; UniformMatrix<4> u_matrix = {"u_matrix", *this}; - Uniform<std::array<GLfloat, 4>> u_color = {"u_color", *this}; + Uniform<Color> u_color = {"u_color", *this}; Uniform<GLfloat> u_opacity = {"u_opacity", *this}; Uniform<GLfloat> u_linewidth = {"u_linewidth", *this}; Uniform<GLfloat> u_gapwidth = {"u_gapwidth", *this}; @@ -29,9 +30,6 @@ public: Uniform<GLfloat> u_extra = {"u_extra", *this}; Uniform<GLfloat> u_offset = {"u_offset", *this}; UniformMatrix<2> u_antialiasingmatrix = {"u_antialiasingmatrix", *this}; - -private: - GLint a_data = -1; }; diff --git a/src/mbgl/shader/outline_shader.cpp b/src/mbgl/shader/outline_shader.cpp index 58a647f375..58f73d9f44 100644 --- a/src/mbgl/shader/outline_shader.cpp +++ b/src/mbgl/shader/outline_shader.cpp @@ -3,15 +3,18 @@ #include <mbgl/shader/outline.fragment.hpp> #include <mbgl/gl/gl.hpp> -#include <cstdio> +namespace mbgl { -using namespace mbgl; - -OutlineShader::OutlineShader(gl::ObjectStore& store) - : Shader("outline", shaders::outline::vertex, shaders::outline::fragment, store) { +OutlineShader::OutlineShader(gl::ObjectStore& store, Defines defines) + : Shader(shaders::outline::name, + shaders::outline::vertex, + shaders::outline::fragment, + store, defines) { } void OutlineShader::bind(GLbyte* offset) { MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos)); MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset)); } + +} // namespace mbgl diff --git a/src/mbgl/shader/outline_shader.hpp b/src/mbgl/shader/outline_shader.hpp index 25c873b4fe..5840ad2238 100644 --- a/src/mbgl/shader/outline_shader.hpp +++ b/src/mbgl/shader/outline_shader.hpp @@ -2,17 +2,18 @@ #include <mbgl/shader/shader.hpp> #include <mbgl/shader/uniform.hpp> +#include <mbgl/util/color.hpp> namespace mbgl { class OutlineShader : public Shader { public: - OutlineShader(gl::ObjectStore&); + OutlineShader(gl::ObjectStore&, Defines defines = None); void bind(GLbyte *offset) final; UniformMatrix<4> u_matrix = {"u_matrix", *this}; - Uniform<std::array<GLfloat, 4>> u_outline_color = {"u_outline_color", *this}; + Uniform<Color> u_outline_color = {"u_outline_color", *this}; Uniform<GLfloat> u_opacity = {"u_opacity", *this}; Uniform<std::array<GLfloat, 2>> u_world = {"u_world", *this}; }; diff --git a/src/mbgl/shader/outlinepattern_shader.cpp b/src/mbgl/shader/outlinepattern_shader.cpp index 5ffa458a4f..2373a75370 100644 --- a/src/mbgl/shader/outlinepattern_shader.cpp +++ b/src/mbgl/shader/outlinepattern_shader.cpp @@ -3,19 +3,18 @@ #include <mbgl/shader/outlinepattern.fragment.hpp> #include <mbgl/gl/gl.hpp> -#include <cstdio> +namespace mbgl { -using namespace mbgl; - -OutlinePatternShader::OutlinePatternShader(gl::ObjectStore& store) - : Shader( - "outlinepattern", - shaders::outlinepattern::vertex, shaders::outlinepattern::fragment, - store - ) { +OutlinePatternShader::OutlinePatternShader(gl::ObjectStore& store, Defines defines) + : Shader(shaders::outlinepattern::name, + shaders::outlinepattern::vertex, + shaders::outlinepattern::fragment, + store, defines) { } void OutlinePatternShader::bind(GLbyte *offset) { MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos)); MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset)); } + +} // namespace mbgl diff --git a/src/mbgl/shader/outlinepattern_shader.hpp b/src/mbgl/shader/outlinepattern_shader.hpp index e124923b6f..6869763412 100644 --- a/src/mbgl/shader/outlinepattern_shader.hpp +++ b/src/mbgl/shader/outlinepattern_shader.hpp @@ -7,23 +7,26 @@ namespace mbgl { class OutlinePatternShader : public Shader { public: - OutlinePatternShader(gl::ObjectStore&); + OutlinePatternShader(gl::ObjectStore&, Defines defines = None); void bind(GLbyte *offset) final; - UniformMatrix<4> u_matrix = {"u_matrix", *this}; - Uniform<std::array<GLfloat, 2>> u_pattern_tl_a = {"u_pattern_tl_a", *this}; - Uniform<std::array<GLfloat, 2>> u_pattern_br_a = {"u_pattern_br_a", *this}; - Uniform<std::array<GLfloat, 2>> u_pattern_tl_b = {"u_pattern_tl_b", *this}; - Uniform<std::array<GLfloat, 2>> u_pattern_br_b = {"u_pattern_br_b", *this}; - Uniform<GLfloat> u_opacity = {"u_opacity", *this}; - Uniform<GLfloat> u_mix = {"u_mix", *this}; - Uniform<GLint> u_image = {"u_image", *this}; - Uniform<std::array<GLfloat, 2>> u_patternscale_a = {"u_patternscale_a", *this}; - Uniform<std::array<GLfloat, 2>> u_patternscale_b = {"u_patternscale_b", *this}; - Uniform<std::array<GLfloat, 2>> u_offset_a = {"u_offset_a", *this}; - Uniform<std::array<GLfloat, 2>> u_offset_b = {"u_offset_b", *this}; - Uniform<std::array<GLfloat, 2>> u_world = {"u_world", *this}; + UniformMatrix<4> u_matrix = {"u_matrix", *this}; + Uniform<std::array<GLfloat, 2>> u_pattern_tl_a = {"u_pattern_tl_a", *this}; + Uniform<std::array<GLfloat, 2>> u_pattern_br_a = {"u_pattern_br_a", *this}; + Uniform<std::array<GLfloat, 2>> u_pattern_tl_b = {"u_pattern_tl_b", *this}; + Uniform<std::array<GLfloat, 2>> u_pattern_br_b = {"u_pattern_br_b", *this}; + Uniform<GLfloat> u_opacity = {"u_opacity", *this}; + Uniform<GLfloat> u_mix = {"u_mix", *this}; + Uniform<GLfloat> u_scale_a = {"u_scale_a", *this}; + Uniform<GLfloat> u_scale_b = {"u_scale_b", *this}; + Uniform<GLfloat> u_tile_units_to_pixels = {"u_tile_units_to_pixels", *this}; + Uniform<GLint> u_image = {"u_image", *this}; + Uniform<std::array<GLfloat, 2>> u_pattern_size_a = {"u_pattern_size_a", *this}; + Uniform<std::array<GLfloat, 2>> u_pattern_size_b = {"u_pattern_size_b", *this}; + Uniform<std::array<GLfloat, 2>> u_pixel_coord_upper = {"u_pixel_coord_upper", *this}; + Uniform<std::array<GLfloat, 2>> u_pixel_coord_lower = {"u_pixel_coord_lower", *this}; + Uniform<std::array<GLfloat, 2>> u_world = {"u_world", *this}; }; } // namespace mbgl diff --git a/src/mbgl/shader/pattern_shader.cpp b/src/mbgl/shader/pattern_shader.cpp index 64a72d1451..5caa892feb 100644 --- a/src/mbgl/shader/pattern_shader.cpp +++ b/src/mbgl/shader/pattern_shader.cpp @@ -3,19 +3,18 @@ #include <mbgl/shader/pattern.fragment.hpp> #include <mbgl/gl/gl.hpp> -#include <cstdio> +namespace mbgl { -using namespace mbgl; - -PatternShader::PatternShader(gl::ObjectStore& store) - : Shader( - "pattern", - shaders::pattern::vertex, shaders::pattern::fragment, - store - ) { +PatternShader::PatternShader(gl::ObjectStore& store, Defines defines) + : Shader(shaders::pattern::name, + shaders::pattern::vertex, + shaders::pattern::fragment, + store, defines) { } void PatternShader::bind(GLbyte *offset) { MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos)); MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset)); } + +} // namespace mbgl diff --git a/src/mbgl/shader/pattern_shader.hpp b/src/mbgl/shader/pattern_shader.hpp index ae515c1948..ae356fdfb7 100644 --- a/src/mbgl/shader/pattern_shader.hpp +++ b/src/mbgl/shader/pattern_shader.hpp @@ -7,22 +7,25 @@ namespace mbgl { class PatternShader : public Shader { public: - PatternShader(gl::ObjectStore&); + PatternShader(gl::ObjectStore&, Defines defines = None); void bind(GLbyte *offset) final; - UniformMatrix<4> u_matrix = {"u_matrix", *this}; - Uniform<std::array<GLfloat, 2>> u_pattern_tl_a = {"u_pattern_tl_a", *this}; - Uniform<std::array<GLfloat, 2>> u_pattern_br_a = {"u_pattern_br_a", *this}; - Uniform<std::array<GLfloat, 2>> u_pattern_tl_b = {"u_pattern_tl_b", *this}; - Uniform<std::array<GLfloat, 2>> u_pattern_br_b = {"u_pattern_br_b", *this}; - Uniform<GLfloat> u_opacity = {"u_opacity", *this}; - Uniform<GLfloat> u_mix = {"u_mix", *this}; - Uniform<GLint> u_image = {"u_image", *this}; - Uniform<std::array<GLfloat, 2>> u_patternscale_a = {"u_patternscale_a", *this}; - Uniform<std::array<GLfloat, 2>> u_patternscale_b = {"u_patternscale_b", *this}; - Uniform<std::array<GLfloat, 2>> u_offset_a = {"u_offset_a", *this}; - Uniform<std::array<GLfloat, 2>> u_offset_b = {"u_offset_b", *this}; + UniformMatrix<4> u_matrix = {"u_matrix", *this}; + Uniform<std::array<GLfloat, 2>> u_pattern_tl_a = {"u_pattern_tl_a", *this}; + Uniform<std::array<GLfloat, 2>> u_pattern_br_a = {"u_pattern_br_a", *this}; + Uniform<std::array<GLfloat, 2>> u_pattern_tl_b = {"u_pattern_tl_b", *this}; + Uniform<std::array<GLfloat, 2>> u_pattern_br_b = {"u_pattern_br_b", *this}; + Uniform<GLfloat> u_opacity = {"u_opacity", *this}; + Uniform<GLfloat> u_mix = {"u_mix", *this}; + Uniform<GLfloat> u_scale_a = {"u_scale_a", *this}; + Uniform<GLfloat> u_scale_b = {"u_scale_b", *this}; + Uniform<GLfloat> u_tile_units_to_pixels = {"u_tile_units_to_pixels", *this}; + Uniform<GLint> u_image = {"u_image", *this}; + Uniform<std::array<GLfloat, 2>> u_pattern_size_a = {"u_pattern_size_a", *this}; + Uniform<std::array<GLfloat, 2>> u_pattern_size_b = {"u_pattern_size_b", *this}; + Uniform<std::array<GLfloat, 2>> u_pixel_coord_upper = {"u_pixel_coord_upper", *this}; + Uniform<std::array<GLfloat, 2>> u_pixel_coord_lower = {"u_pixel_coord_lower", *this}; }; } // namespace mbgl diff --git a/src/mbgl/shader/plain_shader.cpp b/src/mbgl/shader/plain_shader.cpp index c030a2d7b3..1309c4f14a 100644 --- a/src/mbgl/shader/plain_shader.cpp +++ b/src/mbgl/shader/plain_shader.cpp @@ -3,15 +3,18 @@ #include <mbgl/shader/fill.fragment.hpp> #include <mbgl/gl/gl.hpp> -#include <cstdio> +namespace mbgl { -using namespace mbgl; - -PlainShader::PlainShader(gl::ObjectStore& store) - : Shader("fill", shaders::fill::vertex, shaders::fill::fragment, store) { +PlainShader::PlainShader(gl::ObjectStore& store, Defines defines) + : Shader(shaders::fill::name, + shaders::fill::vertex, + shaders::fill::fragment, + store, defines) { } void PlainShader::bind(GLbyte* offset) { MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos)); MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset)); } + +} // namespace mbgl diff --git a/src/mbgl/shader/plain_shader.hpp b/src/mbgl/shader/plain_shader.hpp index 7edf4b4b19..a126fa30a9 100644 --- a/src/mbgl/shader/plain_shader.hpp +++ b/src/mbgl/shader/plain_shader.hpp @@ -2,17 +2,18 @@ #include <mbgl/shader/shader.hpp> #include <mbgl/shader/uniform.hpp> +#include <mbgl/util/color.hpp> namespace mbgl { class PlainShader : public Shader { public: - PlainShader(gl::ObjectStore&); + PlainShader(gl::ObjectStore&, Defines defines = None); void bind(GLbyte *offset) final; UniformMatrix<4> u_matrix = {"u_matrix", *this}; - Uniform<std::array<GLfloat, 4>> u_color = {"u_color", *this}; + Uniform<Color> u_color = {"u_color", *this}; Uniform<GLfloat> u_opacity = {"u_opacity", *this}; }; diff --git a/src/mbgl/shader/raster_shader.cpp b/src/mbgl/shader/raster_shader.cpp index e5e290bedd..76723b06e9 100644 --- a/src/mbgl/shader/raster_shader.cpp +++ b/src/mbgl/shader/raster_shader.cpp @@ -3,15 +3,23 @@ #include <mbgl/shader/raster.fragment.hpp> #include <mbgl/gl/gl.hpp> -#include <cstdio> +namespace mbgl { -using namespace mbgl; - -RasterShader::RasterShader(gl::ObjectStore& store) - : Shader("raster", shaders::raster::vertex, shaders::raster::fragment, store) { +RasterShader::RasterShader(gl::ObjectStore& store, Defines defines) + : Shader(shaders::raster::name, + shaders::raster::vertex, + shaders::raster::fragment, + store, defines) { } void RasterShader::bind(GLbyte* offset) { + const GLint stride = 8; + MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos)); - MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset)); + MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset)); + + MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_texture_pos)); + MBGL_CHECK_ERROR(glVertexAttribPointer(a_texture_pos, 2, GL_SHORT, false, stride, offset + 4)); } + +} // namespace mbgl diff --git a/src/mbgl/shader/raster_shader.hpp b/src/mbgl/shader/raster_shader.hpp index ee53385a0b..4b3ba9168b 100644 --- a/src/mbgl/shader/raster_shader.hpp +++ b/src/mbgl/shader/raster_shader.hpp @@ -7,19 +7,23 @@ namespace mbgl { class RasterShader : public Shader { public: - RasterShader(gl::ObjectStore&); + RasterShader(gl::ObjectStore&, Defines defines = None); void bind(GLbyte *offset) final; UniformMatrix<4> u_matrix = {"u_matrix", *this}; - Uniform<GLint> u_image = {"u_image", *this}; - Uniform<GLfloat> u_opacity = {"u_opacity", *this}; - Uniform<GLfloat> u_buffer = {"u_buffer", *this}; + Uniform<GLint> u_image0 = {"u_image0", *this}; + Uniform<GLint> u_image1 = {"u_image1", *this}; + Uniform<GLfloat> u_opacity0 = {"u_opacity0", *this}; + Uniform<GLfloat> u_opacity1 = {"u_opacity1", *this}; + Uniform<GLfloat> u_buffer_scale = {"u_buffer_scale", *this}; Uniform<GLfloat> u_brightness_low = {"u_brightness_low", *this}; Uniform<GLfloat> u_brightness_high = {"u_brightness_high", *this}; Uniform<GLfloat> u_saturation_factor = {"u_saturation_factor", *this}; Uniform<GLfloat> u_contrast_factor = {"u_contrast_factor", *this}; Uniform<std::array<GLfloat, 3>> u_spin_weights = {"u_spin_weights", *this}; + Uniform<std::array<GLfloat, 2>> u_tl_parent = {"u_tl_parent", *this}; + Uniform<GLfloat> u_scale_parent = {"u_scale_parent", *this}; }; } // namespace mbgl diff --git a/src/mbgl/shader/sdf_shader.cpp b/src/mbgl/shader/sdf_shader.cpp index 76ea1e3b4d..24b6f77d68 100644 --- a/src/mbgl/shader/sdf_shader.cpp +++ b/src/mbgl/shader/sdf_shader.cpp @@ -3,18 +3,16 @@ #include <mbgl/shader/sdf.fragment.hpp> #include <mbgl/gl/gl.hpp> -#include <cstdio> +namespace mbgl { -using namespace mbgl; - -SDFShader::SDFShader(gl::ObjectStore& store) - : Shader("sdf", shaders::sdf::vertex, shaders::sdf::fragment, store) - , a_offset(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_offset"))) - , a_data1(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data1"))) - , a_data2(MBGL_CHECK_ERROR(glGetAttribLocation(getID(), "a_data2"))) { +SDFShader::SDFShader(gl::ObjectStore& store, Defines defines) + : Shader(shaders::sdf::name, + shaders::sdf::vertex, + shaders::sdf::fragment, + store, defines) { } -void SDFGlyphShader::bind(GLbyte* offset) { +void SDFShader::bind(GLbyte* offset) { const int stride = 16; MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos)); @@ -30,18 +28,4 @@ void SDFGlyphShader::bind(GLbyte* offset) { MBGL_CHECK_ERROR(glVertexAttribPointer(a_data2, 4, GL_UNSIGNED_BYTE, false, stride, offset + 12)); } -void SDFIconShader::bind(GLbyte* offset) { - const int stride = 16; - - MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_pos)); - MBGL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0)); - - MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_offset)); - MBGL_CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4)); - - MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data1)); - MBGL_CHECK_ERROR(glVertexAttribPointer(a_data1, 4, GL_UNSIGNED_BYTE, false, stride, offset + 8)); - - MBGL_CHECK_ERROR(glEnableVertexAttribArray(a_data2)); - MBGL_CHECK_ERROR(glVertexAttribPointer(a_data2, 4, GL_UNSIGNED_BYTE, false, stride, offset + 12)); -} +} // namespace mbgl diff --git a/src/mbgl/shader/sdf_shader.hpp b/src/mbgl/shader/sdf_shader.hpp index f067c30aeb..f2f79f1cc9 100644 --- a/src/mbgl/shader/sdf_shader.hpp +++ b/src/mbgl/shader/sdf_shader.hpp @@ -2,40 +2,30 @@ #include <mbgl/shader/shader.hpp> #include <mbgl/shader/uniform.hpp> +#include <mbgl/util/color.hpp> namespace mbgl { class SDFShader : public Shader { public: - SDFShader(gl::ObjectStore&); + SDFShader(gl::ObjectStore&, Defines defines = None); UniformMatrix<4> u_matrix = {"u_matrix", *this}; Uniform<std::array<GLfloat, 2>> u_extrude_scale = {"u_extrude_scale", *this}; - Uniform<std::array<GLfloat, 4>> u_color = {"u_color", *this}; + Uniform<Color> u_color = {"u_color", *this}; Uniform<GLfloat> u_opacity = {"u_opacity", *this}; Uniform<std::array<GLfloat, 2>> u_texsize = {"u_texsize", *this}; Uniform<GLfloat> u_buffer = {"u_buffer", *this}; Uniform<GLfloat> u_gamma = {"u_gamma", *this}; Uniform<GLfloat> u_zoom = {"u_zoom", *this}; - Uniform<GLint> u_skewed = {"u_skewed", *this}; + Uniform<GLfloat> u_pitch = {"u_pitch", *this}; + Uniform<GLfloat> u_bearing = {"u_bearing", *this}; + Uniform<GLfloat> u_aspect_ratio = {"u_aspect_ratio", *this}; + Uniform<GLint> u_rotate_with_map = {"u_rotate_with_map",*this}; + Uniform<GLint> u_pitch_with_map = {"u_pitch_with_map",*this}; Uniform<GLint> u_texture = {"u_texture", *this}; Uniform<GLint> u_fadetexture = {"u_fadetexture", *this}; -protected: - GLint a_offset = -1; - GLint a_data1 = -1; - GLint a_data2 = -1; -}; - -class SDFGlyphShader : public SDFShader { -public: - SDFGlyphShader(gl::ObjectStore& store) : SDFShader(store) {} - void bind(GLbyte *offset) final; -}; - -class SDFIconShader : public SDFShader { -public: - SDFIconShader(gl::ObjectStore& store) : SDFShader(store) {} void bind(GLbyte *offset) final; }; diff --git a/src/mbgl/shader/shader.cpp b/src/mbgl/shader/shader.cpp index 23ea043720..ae36d21740 100644 --- a/src/mbgl/shader/shader.cpp +++ b/src/mbgl/shader/shader.cpp @@ -8,12 +8,14 @@ #include <cstring> #include <cassert> #include <iostream> +#include <string> #include <fstream> #include <cstdio> +#include <cassert> namespace mbgl { -Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSource, gl::ObjectStore& store) +Shader::Shader(const char* name_, const char* vertexSource, const char* fragmentSource, gl::ObjectStore& store, Defines defines) : name(name_) , program(store.createProgram()) , vertexShader(store.createShader(GL_VERTEX_SHADER)) @@ -21,13 +23,19 @@ Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSo { util::stopwatch stopwatch("shader compilation", Event::Shader); - if (!compileShader(vertexShader, &vertSource)) { - Log::Error(Event::Shader, "Vertex shader %s failed to compile: %s", name, vertSource); + if (!compileShader(vertexShader, vertexSource)) { + Log::Error(Event::Shader, "Vertex shader %s failed to compile: %s", name, vertexSource); throw util::ShaderException(std::string { "Vertex shader " } + name + " failed to compile"); } - if (!compileShader(fragmentShader, &fragSource)) { - Log::Error(Event::Shader, "Fragment shader %s failed to compile: %s", name, fragSource); + std::string fragment(fragmentSource); + if (defines & Defines::Overdraw) { + assert(fragment.find("#ifdef OVERDRAW_INSPECTOR") != std::string::npos); + fragment.replace(fragment.find_first_of('\n'), 1, "\n#define OVERDRAW_INSPECTOR\n"); + } + + if (!compileShader(fragmentShader, fragment.c_str())) { + Log::Error(Event::Shader, "Fragment shader %s failed to compile: %s", name, fragmentSource); throw util::ShaderException(std::string { "Fragment shader " } + name + " failed to compile"); } @@ -35,32 +43,37 @@ Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSo MBGL_CHECK_ERROR(glAttachShader(program.get(), vertexShader.get())); MBGL_CHECK_ERROR(glAttachShader(program.get(), fragmentShader.get())); - { - // Link program - GLint status; - MBGL_CHECK_ERROR(glLinkProgram(program.get())); + // Bind attribute variables + MBGL_CHECK_ERROR(glBindAttribLocation(program.get(), a_pos, "a_pos")); + MBGL_CHECK_ERROR(glBindAttribLocation(program.get(), a_extrude, "a_extrude")); + MBGL_CHECK_ERROR(glBindAttribLocation(program.get(), a_offset, "a_offset")); + MBGL_CHECK_ERROR(glBindAttribLocation(program.get(), a_data, "a_data")); + MBGL_CHECK_ERROR(glBindAttribLocation(program.get(), a_data1, "a_data1")); + MBGL_CHECK_ERROR(glBindAttribLocation(program.get(), a_data2, "a_data2")); + MBGL_CHECK_ERROR(glBindAttribLocation(program.get(), a_texture_pos, "a_texture_pos")); - MBGL_CHECK_ERROR(glGetProgramiv(program.get(), GL_LINK_STATUS, &status)); - if (status == 0) { - GLint logLength; - MBGL_CHECK_ERROR(glGetProgramiv(program.get(), GL_INFO_LOG_LENGTH, &logLength)); - const auto log = std::make_unique<GLchar[]>(logLength); - if (logLength > 0) { - MBGL_CHECK_ERROR(glGetProgramInfoLog(program.get(), logLength, &logLength, log.get())); - Log::Error(Event::Shader, "Program failed to link: %s", log.get()); - } - throw util::ShaderException(std::string { "Program " } + name + " failed to link: " + log.get()); + // Link program + GLint status; + MBGL_CHECK_ERROR(glLinkProgram(program.get())); + + MBGL_CHECK_ERROR(glGetProgramiv(program.get(), GL_LINK_STATUS, &status)); + if (status == 0) { + GLint logLength; + MBGL_CHECK_ERROR(glGetProgramiv(program.get(), GL_INFO_LOG_LENGTH, &logLength)); + const auto log = std::make_unique<GLchar[]>(logLength); + if (logLength > 0) { + MBGL_CHECK_ERROR(glGetProgramInfoLog(program.get(), logLength, &logLength, log.get())); + Log::Error(Event::Shader, "Program failed to link: %s", log.get()); } + throw util::ShaderException(std::string { "Program " } + name + " failed to link: " + log.get()); } - - a_pos = MBGL_CHECK_ERROR(glGetAttribLocation(program.get(), "a_pos")); } -bool Shader::compileShader(gl::UniqueShader& shader, const GLchar *source[]) { +bool Shader::compileShader(gl::UniqueShader& shader, const GLchar *source) { GLint status = 0; - const GLsizei lengths = static_cast<GLsizei>(std::strlen(*source)); - MBGL_CHECK_ERROR(glShaderSource(shader.get(), 1, source, &lengths)); + const GLsizei lengths = static_cast<GLsizei>(std::strlen(source)); + MBGL_CHECK_ERROR(glShaderSource(shader.get(), 1, &source, &lengths)); MBGL_CHECK_ERROR(glCompileShader(shader.get())); diff --git a/src/mbgl/shader/shader.hpp b/src/mbgl/shader/shader.hpp index 1cb2a5601f..f7da0c91ab 100644 --- a/src/mbgl/shader/shader.hpp +++ b/src/mbgl/shader/shader.hpp @@ -3,15 +3,14 @@ #include <mbgl/gl/gl.hpp> #include <mbgl/gl/object_store.hpp> #include <mbgl/util/noncopyable.hpp> +#include <mbgl/util/optional.hpp> namespace mbgl { class Shader : private util::noncopyable { public: - Shader(const GLchar *name, const GLchar *vertex, const GLchar *fragment, gl::ObjectStore&); - ~Shader(); - const GLchar *name; + const char* name; GLuint getID() const { return program.get(); @@ -19,11 +18,28 @@ public: virtual void bind(GLbyte *offset) = 0; + enum Defines : bool { + None = false, + Overdraw = true, + }; + protected: - GLint a_pos = -1; + Shader(const char* name_, + const char* vertex, + const char* fragment, + gl::ObjectStore&, + Defines defines = Defines::None); + + static constexpr GLint a_pos = 0; + static constexpr GLint a_extrude = 1; + static constexpr GLint a_offset = 2; + static constexpr GLint a_data = 3; + static constexpr GLint a_data1 = 4; + static constexpr GLint a_data2 = 5; + static constexpr GLint a_texture_pos = 6; private: - bool compileShader(gl::UniqueShader&, const GLchar *source[]); + bool compileShader(gl::UniqueShader&, const GLchar *source); gl::UniqueProgram program; gl::UniqueShader vertexShader; diff --git a/src/mbgl/shader/shaders.hpp b/src/mbgl/shader/shaders.hpp new file mode 100644 index 0000000000..088e351d37 --- /dev/null +++ b/src/mbgl/shader/shaders.hpp @@ -0,0 +1,59 @@ +#pragma once + +#include <mbgl/gl/gl.hpp> +#include <mbgl/gl/object_store.hpp> + +#include <mbgl/shader/pattern_shader.hpp> +#include <mbgl/shader/plain_shader.hpp> +#include <mbgl/shader/outline_shader.hpp> +#include <mbgl/shader/outlinepattern_shader.hpp> +#include <mbgl/shader/line_shader.hpp> +#include <mbgl/shader/linesdf_shader.hpp> +#include <mbgl/shader/linepattern_shader.hpp> +#include <mbgl/shader/icon_shader.hpp> +#include <mbgl/shader/raster_shader.hpp> +#include <mbgl/shader/sdf_shader.hpp> +#include <mbgl/shader/collision_box_shader.hpp> +#include <mbgl/shader/circle_shader.hpp> + +namespace mbgl { + +class Shaders { +public: + Shaders(gl::ObjectStore& store, Shader::Defines defines = Shader::None) + : plain(store, defines), + outline(store, defines), + outlinePattern(store, defines), + line(store, defines), + linesdf(store, defines), + linepattern(store, defines), + pattern(store, defines), + icon(store, defines), + raster(store, defines), + sdfGlyph(store, defines), + sdfIcon(store, defines), + collisionBox(store), + circle(store, defines) + {} + + PlainShader plain; + OutlineShader outline; + OutlinePatternShader outlinePattern; + LineShader line; + LineSDFShader linesdf; + LinepatternShader linepattern; + PatternShader pattern; + IconShader icon; + RasterShader raster; + SDFShader sdfGlyph; + SDFShader sdfIcon; + CollisionBoxShader collisionBox; + CircleShader circle; + + VertexArrayObject coveringPlainArray; + VertexArrayObject coveringRasterArray; + VertexArrayObject backgroundPatternArray; + VertexArrayObject backgroundArray; +}; + +} // namespace mbgl diff --git a/src/mbgl/shader/uniform.cpp b/src/mbgl/shader/uniform.cpp index d43dd20016..4c7646119a 100644 --- a/src/mbgl/shader/uniform.cpp +++ b/src/mbgl/shader/uniform.cpp @@ -1,4 +1,5 @@ #include <mbgl/shader/uniform.hpp> +#include <mbgl/util/color.hpp> namespace mbgl { @@ -28,6 +29,12 @@ void Uniform<std::array<GLfloat, 4>>::bind(const std::array<GLfloat, 4>& t) { } template <> +void Uniform<Color>::bind(const Color& t) { + std::array<GLfloat, 4> a = {{ t.r, t.g, t.b, t.a }}; + MBGL_CHECK_ERROR(glUniform4fv(location, 1, a.data())); +} + +template <> void UniformMatrix<2>::bind(const std::array<GLfloat, 4>& t) { MBGL_CHECK_ERROR(glUniformMatrix2fv(location, 1, GL_FALSE, t.data())); } |