From 66bdbc3b969083b9d647abdf72784be64a125949 Mon Sep 17 00:00:00 2001 From: John Firebaugh Date: Fri, 28 Oct 2016 18:17:33 -0700 Subject: [core] Introduce gl::Program template --- cmake/core-files.cmake | 65 +++------ cmake/shaders.cmake | 7 +- cmake/test.cmake | 1 + include/mbgl/util/exception.hpp | 5 - scripts/build-shaders.js | 86 +++++------ src/mbgl/gl/attribute.cpp | 4 + src/mbgl/gl/attribute.hpp | 10 +- src/mbgl/gl/context.cpp | 55 ++++++- src/mbgl/gl/context.hpp | 6 +- src/mbgl/gl/drawable.hpp | 16 +-- src/mbgl/gl/program.hpp | 37 +++++ src/mbgl/gl/shader.cpp | 113 --------------- src/mbgl/gl/shader.hpp | 45 ------ src/mbgl/gl/types.hpp | 5 + src/mbgl/gl/uniform.cpp | 4 + src/mbgl/gl/uniform.hpp | 14 +- src/mbgl/layout/symbol_layout.cpp | 16 +-- src/mbgl/programs/attributes.hpp | 23 +++ src/mbgl/programs/circle_program.cpp | 7 + src/mbgl/programs/circle_program.hpp | 52 +++++++ src/mbgl/programs/collision_box_program.cpp | 7 + src/mbgl/programs/collision_box_program.hpp | 53 +++++++ src/mbgl/programs/fill_program.cpp | 47 ++++++ src/mbgl/programs/fill_program.hpp | 119 +++++++++++++++ src/mbgl/programs/line_program.cpp | 135 +++++++++++++++++ src/mbgl/programs/line_program.hpp | 184 ++++++++++++++++++++++++ src/mbgl/programs/program.hpp | 31 ++++ src/mbgl/programs/programs.hpp | 46 ++++++ src/mbgl/programs/raster_program.cpp | 7 + src/mbgl/programs/raster_program.hpp | 65 +++++++++ src/mbgl/programs/symbol_program.cpp | 145 +++++++++++++++++++ src/mbgl/programs/symbol_program.hpp | 134 +++++++++++++++++ src/mbgl/programs/uniforms.hpp | 33 +++++ src/mbgl/renderer/circle_bucket.cpp | 10 +- src/mbgl/renderer/circle_bucket.hpp | 2 +- src/mbgl/renderer/debug_bucket.cpp | 3 +- src/mbgl/renderer/debug_bucket.hpp | 2 +- src/mbgl/renderer/fill_bucket.cpp | 5 +- src/mbgl/renderer/fill_bucket.hpp | 2 +- src/mbgl/renderer/line_bucket.hpp | 2 +- src/mbgl/renderer/paint_parameters.hpp | 4 +- src/mbgl/renderer/painter.cpp | 18 +-- src/mbgl/renderer/painter.hpp | 11 +- src/mbgl/renderer/painter_background.cpp | 10 +- src/mbgl/renderer/painter_circle.cpp | 8 +- src/mbgl/renderer/painter_clipping.cpp | 8 +- src/mbgl/renderer/painter_debug.cpp | 8 +- src/mbgl/renderer/painter_fill.cpp | 24 ++-- src/mbgl/renderer/painter_line.cpp | 20 +-- src/mbgl/renderer/painter_raster.cpp | 8 +- src/mbgl/renderer/painter_symbol.cpp | 34 ++--- src/mbgl/renderer/raster_bucket.cpp | 2 +- src/mbgl/renderer/symbol_bucket.hpp | 4 +- src/mbgl/shader/attributes.hpp | 23 --- src/mbgl/shader/circle_attributes.hpp | 30 ---- src/mbgl/shader/circle_shader.cpp | 16 --- src/mbgl/shader/circle_shader.hpp | 20 --- src/mbgl/shader/circle_uniforms.hpp | 23 --- src/mbgl/shader/collision_box_attributes.hpp | 36 ----- src/mbgl/shader/collision_box_shader.cpp | 17 --- src/mbgl/shader/collision_box_shader.hpp | 20 --- src/mbgl/shader/collision_box_uniforms.hpp | 18 --- src/mbgl/shader/fill_attributes.hpp | 24 ---- src/mbgl/shader/fill_outline_pattern_shader.cpp | 16 --- src/mbgl/shader/fill_outline_pattern_shader.hpp | 20 --- src/mbgl/shader/fill_outline_shader.cpp | 16 --- src/mbgl/shader/fill_outline_shader.hpp | 20 --- src/mbgl/shader/fill_pattern_shader.cpp | 16 --- src/mbgl/shader/fill_pattern_shader.hpp | 20 --- src/mbgl/shader/fill_shader.cpp | 16 --- src/mbgl/shader/fill_shader.hpp | 20 --- src/mbgl/shader/fill_uniforms.cpp | 45 ------ src/mbgl/shader/fill_uniforms.hpp | 63 -------- src/mbgl/shader/line_attributes.hpp | 60 -------- src/mbgl/shader/line_pattern_shader.cpp | 16 --- src/mbgl/shader/line_pattern_shader.hpp | 20 --- src/mbgl/shader/line_sdf_shader.cpp | 16 --- src/mbgl/shader/line_sdf_shader.hpp | 21 --- src/mbgl/shader/line_shader.cpp | 16 --- src/mbgl/shader/line_shader.hpp | 21 --- src/mbgl/shader/line_uniforms.cpp | 133 ----------------- src/mbgl/shader/line_uniforms.hpp | 109 -------------- src/mbgl/shader/raster_attributes.hpp | 29 ---- src/mbgl/shader/raster_shader.cpp | 16 --- src/mbgl/shader/raster_shader.hpp | 20 --- src/mbgl/shader/raster_uniforms.hpp | 37 ----- src/mbgl/shader/shaders.hpp | 53 ------- src/mbgl/shader/symbol_attributes.hpp | 50 ------- src/mbgl/shader/symbol_icon_shader.cpp | 16 --- src/mbgl/shader/symbol_icon_shader.hpp | 20 --- src/mbgl/shader/symbol_sdf_shader.cpp | 16 --- src/mbgl/shader/symbol_sdf_shader.hpp | 20 --- src/mbgl/shader/symbol_uniforms.cpp | 143 ------------------ src/mbgl/shader/symbol_uniforms.hpp | 77 ---------- src/mbgl/shader/uniforms.hpp | 33 ----- test/gl/object.test.cpp | 28 ++-- 96 files changed, 1372 insertions(+), 1839 deletions(-) create mode 100644 src/mbgl/gl/program.hpp delete mode 100644 src/mbgl/gl/shader.cpp delete mode 100644 src/mbgl/gl/shader.hpp create mode 100644 src/mbgl/programs/attributes.hpp create mode 100644 src/mbgl/programs/circle_program.cpp create mode 100644 src/mbgl/programs/circle_program.hpp create mode 100644 src/mbgl/programs/collision_box_program.cpp create mode 100644 src/mbgl/programs/collision_box_program.hpp create mode 100644 src/mbgl/programs/fill_program.cpp create mode 100644 src/mbgl/programs/fill_program.hpp create mode 100644 src/mbgl/programs/line_program.cpp create mode 100644 src/mbgl/programs/line_program.hpp create mode 100644 src/mbgl/programs/program.hpp create mode 100644 src/mbgl/programs/programs.hpp create mode 100644 src/mbgl/programs/raster_program.cpp create mode 100644 src/mbgl/programs/raster_program.hpp create mode 100644 src/mbgl/programs/symbol_program.cpp create mode 100644 src/mbgl/programs/symbol_program.hpp create mode 100644 src/mbgl/programs/uniforms.hpp delete mode 100644 src/mbgl/shader/attributes.hpp delete mode 100644 src/mbgl/shader/circle_attributes.hpp delete mode 100644 src/mbgl/shader/circle_shader.cpp delete mode 100644 src/mbgl/shader/circle_shader.hpp delete mode 100644 src/mbgl/shader/circle_uniforms.hpp delete mode 100644 src/mbgl/shader/collision_box_attributes.hpp delete mode 100644 src/mbgl/shader/collision_box_shader.cpp delete mode 100644 src/mbgl/shader/collision_box_shader.hpp delete mode 100644 src/mbgl/shader/collision_box_uniforms.hpp delete mode 100644 src/mbgl/shader/fill_attributes.hpp delete mode 100644 src/mbgl/shader/fill_outline_pattern_shader.cpp delete mode 100644 src/mbgl/shader/fill_outline_pattern_shader.hpp delete mode 100644 src/mbgl/shader/fill_outline_shader.cpp delete mode 100644 src/mbgl/shader/fill_outline_shader.hpp delete mode 100644 src/mbgl/shader/fill_pattern_shader.cpp delete mode 100644 src/mbgl/shader/fill_pattern_shader.hpp delete mode 100644 src/mbgl/shader/fill_shader.cpp delete mode 100644 src/mbgl/shader/fill_shader.hpp delete mode 100644 src/mbgl/shader/fill_uniforms.cpp delete mode 100644 src/mbgl/shader/fill_uniforms.hpp delete mode 100644 src/mbgl/shader/line_attributes.hpp delete mode 100644 src/mbgl/shader/line_pattern_shader.cpp delete mode 100644 src/mbgl/shader/line_pattern_shader.hpp delete mode 100644 src/mbgl/shader/line_sdf_shader.cpp delete mode 100644 src/mbgl/shader/line_sdf_shader.hpp delete mode 100644 src/mbgl/shader/line_shader.cpp delete mode 100644 src/mbgl/shader/line_shader.hpp delete mode 100644 src/mbgl/shader/line_uniforms.cpp delete mode 100644 src/mbgl/shader/line_uniforms.hpp delete mode 100644 src/mbgl/shader/raster_attributes.hpp delete mode 100644 src/mbgl/shader/raster_shader.cpp delete mode 100644 src/mbgl/shader/raster_shader.hpp delete mode 100644 src/mbgl/shader/raster_uniforms.hpp delete mode 100644 src/mbgl/shader/shaders.hpp delete mode 100644 src/mbgl/shader/symbol_attributes.hpp delete mode 100644 src/mbgl/shader/symbol_icon_shader.cpp delete mode 100644 src/mbgl/shader/symbol_icon_shader.hpp delete mode 100644 src/mbgl/shader/symbol_sdf_shader.cpp delete mode 100644 src/mbgl/shader/symbol_sdf_shader.hpp delete mode 100644 src/mbgl/shader/symbol_uniforms.cpp delete mode 100644 src/mbgl/shader/symbol_uniforms.hpp delete mode 100644 src/mbgl/shader/uniforms.hpp diff --git a/cmake/core-files.cmake b/cmake/core-files.cmake index 07a11e9a9f..7a2ed33281 100644 --- a/cmake/core-files.cmake +++ b/cmake/core-files.cmake @@ -73,10 +73,9 @@ set(MBGL_CORE_FILES src/mbgl/gl/index_buffer.hpp src/mbgl/gl/object.cpp src/mbgl/gl/object.hpp + src/mbgl/gl/program.hpp src/mbgl/gl/renderbuffer.hpp src/mbgl/gl/segment.hpp - src/mbgl/gl/shader.cpp - src/mbgl/gl/shader.hpp src/mbgl/gl/state.hpp src/mbgl/gl/stencil_mode.cpp src/mbgl/gl/stencil_mode.hpp @@ -149,6 +148,24 @@ set(MBGL_CORE_FILES include/mbgl/platform/default/settings_json.hpp include/mbgl/platform/default/thread_pool.hpp + # programs + src/mbgl/programs/attributes.hpp + src/mbgl/programs/circle_program.cpp + src/mbgl/programs/circle_program.hpp + src/mbgl/programs/collision_box_program.cpp + src/mbgl/programs/collision_box_program.hpp + src/mbgl/programs/fill_program.cpp + src/mbgl/programs/fill_program.hpp + src/mbgl/programs/line_program.cpp + src/mbgl/programs/line_program.hpp + src/mbgl/programs/program.hpp + src/mbgl/programs/programs.hpp + src/mbgl/programs/raster_program.cpp + src/mbgl/programs/raster_program.hpp + src/mbgl/programs/symbol_program.cpp + src/mbgl/programs/symbol_program.hpp + src/mbgl/programs/uniforms.hpp + # renderer src/mbgl/renderer/bucket.hpp src/mbgl/renderer/circle_bucket.cpp @@ -181,50 +198,6 @@ set(MBGL_CORE_FILES src/mbgl/renderer/symbol_bucket.cpp src/mbgl/renderer/symbol_bucket.hpp - # shader - src/mbgl/shader/attributes.hpp - src/mbgl/shader/circle_attributes.hpp - src/mbgl/shader/circle_shader.cpp - src/mbgl/shader/circle_shader.hpp - src/mbgl/shader/circle_uniforms.hpp - src/mbgl/shader/collision_box_attributes.hpp - src/mbgl/shader/collision_box_shader.cpp - src/mbgl/shader/collision_box_shader.hpp - src/mbgl/shader/collision_box_uniforms.hpp - src/mbgl/shader/fill_attributes.hpp - src/mbgl/shader/fill_outline_pattern_shader.cpp - src/mbgl/shader/fill_outline_pattern_shader.hpp - src/mbgl/shader/fill_outline_shader.cpp - src/mbgl/shader/fill_outline_shader.hpp - src/mbgl/shader/fill_pattern_shader.cpp - src/mbgl/shader/fill_pattern_shader.hpp - src/mbgl/shader/fill_shader.cpp - src/mbgl/shader/fill_shader.hpp - src/mbgl/shader/fill_uniforms.cpp - src/mbgl/shader/fill_uniforms.hpp - src/mbgl/shader/line_attributes.hpp - src/mbgl/shader/line_pattern_shader.cpp - src/mbgl/shader/line_pattern_shader.hpp - src/mbgl/shader/line_sdf_shader.cpp - src/mbgl/shader/line_sdf_shader.hpp - src/mbgl/shader/line_shader.cpp - src/mbgl/shader/line_shader.hpp - src/mbgl/shader/line_uniforms.cpp - src/mbgl/shader/line_uniforms.hpp - src/mbgl/shader/raster_attributes.hpp - src/mbgl/shader/raster_shader.cpp - src/mbgl/shader/raster_shader.hpp - src/mbgl/shader/raster_uniforms.hpp - src/mbgl/shader/shaders.hpp - src/mbgl/shader/symbol_attributes.hpp - src/mbgl/shader/symbol_icon_shader.cpp - src/mbgl/shader/symbol_icon_shader.hpp - src/mbgl/shader/symbol_sdf_shader.cpp - src/mbgl/shader/symbol_sdf_shader.hpp - src/mbgl/shader/symbol_uniforms.cpp - src/mbgl/shader/symbol_uniforms.hpp - src/mbgl/shader/uniforms.hpp - # sprite include/mbgl/sprite/sprite_image.hpp src/mbgl/sprite/sprite_atlas.cpp diff --git a/cmake/shaders.cmake b/cmake/shaders.cmake index bebf476bbf..659231fd9a 100644 --- a/cmake/shaders.cmake +++ b/cmake/shaders.cmake @@ -4,14 +4,13 @@ function(add_shader VAR name) set(shader_source_prefix ${MBGL_GENERATED}/include/mbgl/shader) add_custom_command( - OUTPUT ${shader_source_prefix}/${name}.vertex.hpp ${shader_source_prefix}/${name}.fragment.hpp - COMMAND ${shader_build_cmd} ${shader_file_prefix}/${name}.vertex.glsl ${shader_source_prefix}/${name}.vertex.hpp - COMMAND ${shader_build_cmd} ${shader_file_prefix}/${name}.fragment.glsl ${shader_source_prefix}/${name}.fragment.hpp + OUTPUT ${shader_source_prefix}/${name}.hpp + COMMAND ${shader_build_cmd} ${shader_file_prefix}/${name}.vertex.glsl ${shader_file_prefix}/${name}.fragment.glsl ${shader_source_prefix}/${name}.hpp DEPENDS ${shader_file_prefix}/${name}.vertex.glsl DEPENDS ${shader_file_prefix}/${name}.fragment.glsl VERBATIM ) - set(${VAR} ${${VAR}} ${shader_source_prefix}/${name}.vertex.hpp ${shader_source_prefix}/${name}.fragment.hpp PARENT_SCOPE) + set(${VAR} ${${VAR}} ${shader_source_prefix}/${name}.hpp PARENT_SCOPE) endfunction() add_shader(MBGL_SHADER_FILES circle) diff --git a/cmake/test.cmake b/cmake/test.cmake index 2a83a633c0..fc7a22874c 100644 --- a/cmake/test.cmake +++ b/cmake/test.cmake @@ -14,6 +14,7 @@ target_include_directories(mbgl-test PRIVATE test/include PRIVATE test/src PRIVATE platform/default + PRIVATE ${MBGL_GENERATED}/include ) target_link_libraries(mbgl-test diff --git a/include/mbgl/util/exception.hpp b/include/mbgl/util/exception.hpp index 7c331636d4..46de8528c7 100644 --- a/include/mbgl/util/exception.hpp +++ b/include/mbgl/util/exception.hpp @@ -20,10 +20,5 @@ struct MisuseException : Exception { MisuseException(const std::string &msg) : Exception(msg) {} }; -struct ShaderException : Exception { - ShaderException(const char *msg) : Exception(msg) {} - ShaderException(const std::string &msg) : Exception(msg) {} -}; - } // namespace util } // namespace mbgl diff --git a/scripts/build-shaders.js b/scripts/build-shaders.js index 9090f19e6d..dd2de9daf6 100755 --- a/scripts/build-shaders.js +++ b/scripts/build-shaders.js @@ -4,68 +4,54 @@ var path = require('path'); var fs = require('fs'); var mkdirp = require('mkdirp'); -var input_file = process.argv[2] -var output_file = process.argv[3]; +var vertex_file = process.argv[2]; +var fragment_file = process.argv[3]; +var output_file = process.argv[4]; -if (!input_file || !output_file) { +if (!vertex_file || !fragment_file || !output_file) { console.warn('No input or output file given.'); - console.warn('Usage: %s [input.vertex.glsl] [output.vertex.hpp]', path.basename(process.argv[1])); + console.warn('Usage: %s input.vertex.glsl input.fragment.glsl output.hpp', path.basename(process.argv[1])); process.exit(1); } -var components = path.basename(input_file).split('.'); - +var components = path.basename(vertex_file).split('.'); var shader_name = components[0]; -var shader_type = components[1]; -var extension = components[2]; - -var data = fs.readFileSync(input_file, 'utf8'); - -// Replace uniform pragmas var pragma_mapbox_regex = /(\s*)#pragma\s+mapbox\s*:\s+(define|initialize)\s+(low|medium|high)p\s+(float|vec(?:2|3|4))\s+(.*)/; -var data = data.split('\n').map(function(line) { - var params = line.match(pragma_mapbox_regex); - if (params) { - if (params[2] === 'define') { - return params[1] + 'uniform ' + params[3] + 'p ' + params[4] + ' u_' + params[5] + ';'; +function source(file) { + return '\n' + fs.readFileSync(file, 'utf8').split('\n').map(function(line) { + var params = line.match(pragma_mapbox_regex); + if (params) { + if (params[2] === 'define') { + return params[1] + 'uniform ' + params[3] + 'p ' + params[4] + ' u_' + params[5] + ';'; + } else { + return params[1] + params[3] + 'p ' + params[4] + ' ' + params[5] + ' = u_' + params[5] + ';'; + } } else { - return params[1] + params[3] + 'p ' + params[4] + ' ' + params[5] + ' = u_' + params[5] + ';'; + return line; } - } else { - return line; - } -}).join('\n'); - + }).join('\n'); +} -var content = - '#pragma once\n' + - '\n' + - '// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.\n' + - '\n' + - '#include \n' + - '\n' + - 'namespace mbgl {\n' + - 'namespace shaders {\n' + - 'namespace ' + shader_name + ' {\n' + - '\n' + - '#ifndef MBGL_SHADER_NAME_' + shader_name.toUpperCase() + '\n' + - '#define MBGL_SHADER_NAME_' + shader_name.toUpperCase() + '\n' + - 'constexpr const char* name = "' + shader_name + '";\n' + - '#endif // MBGL_SHADER_NAME_' + shader_name.toUpperCase() + '\n' + - '\n' + - 'constexpr const char* ' + shader_type + ' =\n' + - '#ifdef GL_ES_VERSION_2_0\n' + - ' "precision highp float;"\n' + - '#else\n' + - ' "#version 120"\n' + - '#endif\n' + - ' R"MBGL_SHADER(\n' + data + ')MBGL_SHADER";\n' + - '\n' + - '} // namespace ' + shader_name + '\n' + - '} // namespace shaders\n' + - '} // namespace mbgl\n'; +var content = "#pragma once\n" + +"\n" + +"// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED.\n" + +"\n" + +"#include \n" + +"\n" + +"namespace mbgl {\n" + +"namespace shaders {\n" + +"\n" + +"class " + shader_name + " {\n" + +"public:\n" + +" static constexpr const char* name = \"" + shader_name + "\";" + +" static constexpr const char* vertexSource = R\"MBGL_SHADER(" + source(vertex_file) + ")MBGL_SHADER\";\n" + +" static constexpr const char* fragmentSource = R\"MBGL_SHADER(" + source(fragment_file) + ")MBGL_SHADER\";\n" + +"};\n" + +"\n" + +"} // namespace shaders\n" + +"} // namespace mbgl\n"; mkdirp.sync(path.dirname(output_file)); fs.writeFileSync(output_file, content); diff --git a/src/mbgl/gl/attribute.cpp b/src/mbgl/gl/attribute.cpp index 81ab6ac2a5..51fdd1dd12 100644 --- a/src/mbgl/gl/attribute.cpp +++ b/src/mbgl/gl/attribute.cpp @@ -4,6 +4,10 @@ namespace mbgl { namespace gl { +AttributeLocation attributeLocation(ProgramID id, const char* name) { + return MBGL_CHECK_ERROR(glGetAttribLocation(id, name)); +} + void bindAttribute(AttributeLocation location, std::size_t count, DataType type, diff --git a/src/mbgl/gl/attribute.hpp b/src/mbgl/gl/attribute.hpp index e6ef5c7f89..126da38de5 100644 --- a/src/mbgl/gl/attribute.hpp +++ b/src/mbgl/gl/attribute.hpp @@ -1,7 +1,6 @@ #pragma once #include -#include #include #include @@ -18,9 +17,6 @@ public: class State { public: - State(const char* name, const Shader& shader) - : location(shader.getAttributeLocation(name)) {} - AttributeLocation location; static constexpr std::size_t count = N; static constexpr DataType type = DataTypeOf::value; @@ -134,6 +130,8 @@ const std::size_t Vertex::attributeOffsets[5] = { } // namespace detail +AttributeLocation attributeLocation(ProgramID, const char * name); + void bindAttribute(AttributeLocation location, std::size_t count, DataType type, @@ -147,8 +145,8 @@ public: using State = std::tuple; using Vertex = detail::Vertex; - static State state(const Shader& shader) { - return State { { As::name, shader }... }; + static State state(const ProgramID& id) { + return State { { attributeLocation(id, As::name) }... }; } static std::function binder(const State& state) { diff --git a/src/mbgl/gl/context.cpp b/src/mbgl/gl/context.cpp index f23dfe3dbe..b12c77c1a1 100644 --- a/src/mbgl/gl/context.cpp +++ b/src/mbgl/gl/context.cpp @@ -4,12 +4,16 @@ #include #include #include +#include #include namespace mbgl { namespace gl { +static_assert(underlying_type(ShaderType::Vertex) == GL_VERTEX_SHADER, "OpenGL type mismatch"); +static_assert(underlying_type(ShaderType::Fragment) == GL_FRAGMENT_SHADER, "OpenGL type mismatch"); + static_assert(underlying_type(PrimitiveType::Points) == GL_POINTS, "OpenGL type mismatch"); static_assert(underlying_type(PrimitiveType::Lines) == GL_LINES, "OpenGL type mismatch"); static_assert(underlying_type(PrimitiveType::LineLoop) == GL_LINE_LOOP, "OpenGL type mismatch"); @@ -34,16 +38,53 @@ Context::~Context() { reset(); } -UniqueProgram Context::createProgram() { - return UniqueProgram{ MBGL_CHECK_ERROR(glCreateProgram()), { this } }; -} +UniqueShader Context::createShader(ShaderType type, const std::string& source) { + UniqueShader result { MBGL_CHECK_ERROR(glCreateShader(static_cast(type))), { this } }; + + const GLchar* sources = source.data(); + const GLsizei lengths = static_cast(source.length()); + MBGL_CHECK_ERROR(glShaderSource(result, 1, &sources, &lengths)); + MBGL_CHECK_ERROR(glCompileShader(result)); + + GLint status = 0; + MBGL_CHECK_ERROR(glGetShaderiv(result, GL_COMPILE_STATUS, &status)); + if (status != 0) { + return result; + } + + GLint logLength; + MBGL_CHECK_ERROR(glGetShaderiv(result, GL_INFO_LOG_LENGTH, &logLength)); + if (logLength > 0) { + const auto log = std::make_unique(logLength); + MBGL_CHECK_ERROR(glGetShaderInfoLog(result, logLength, &logLength, log.get())); + Log::Error(Event::Shader, "Shader failed to compile: %s", log.get()); + } -UniqueShader Context::createVertexShader() { - return UniqueShader{ MBGL_CHECK_ERROR(glCreateShader(GL_VERTEX_SHADER)), { this } }; + throw std::runtime_error("shader failed to compile"); } -UniqueShader Context::createFragmentShader() { - return UniqueShader{ MBGL_CHECK_ERROR(glCreateShader(GL_FRAGMENT_SHADER)), { this } }; +UniqueProgram Context::createProgram(ShaderID vertexShader, ShaderID fragmentShader) { + UniqueProgram result { MBGL_CHECK_ERROR(glCreateProgram()), { this } }; + + MBGL_CHECK_ERROR(glAttachShader(result, vertexShader)); + MBGL_CHECK_ERROR(glAttachShader(result, fragmentShader)); + MBGL_CHECK_ERROR(glLinkProgram(result)); + + GLint status; + MBGL_CHECK_ERROR(glGetProgramiv(result, GL_LINK_STATUS, &status)); + if (status != 0) { + return result; + } + + GLint logLength; + MBGL_CHECK_ERROR(glGetProgramiv(result, GL_INFO_LOG_LENGTH, &logLength)); + const auto log = std::make_unique(logLength); + if (logLength > 0) { + MBGL_CHECK_ERROR(glGetProgramInfoLog(result, logLength, &logLength, log.get())); + Log::Error(Event::Shader, "Program failed to link: %s", log.get()); + } + + throw std::runtime_error("program failed to link"); } UniqueBuffer Context::createVertexBuffer(const void* data, std::size_t size) { diff --git a/src/mbgl/gl/context.hpp b/src/mbgl/gl/context.hpp index 438450fe14..2a3fbea33d 100644 --- a/src/mbgl/gl/context.hpp +++ b/src/mbgl/gl/context.hpp @@ -14,6 +14,7 @@ #include #include #include +#include #include namespace mbgl { @@ -28,9 +29,8 @@ class Context : private util::noncopyable { public: ~Context(); - UniqueProgram createProgram(); - UniqueShader createVertexShader(); - UniqueShader createFragmentShader(); + UniqueShader createShader(ShaderType type, const std::string& source); + UniqueProgram createProgram(ShaderID vertexShader, ShaderID fragmentShader); UniqueTexture createTexture(); template diff --git a/src/mbgl/gl/drawable.hpp b/src/mbgl/gl/drawable.hpp index be6b27bb83..747d8facf0 100644 --- a/src/mbgl/gl/drawable.hpp +++ b/src/mbgl/gl/drawable.hpp @@ -82,28 +82,28 @@ auto Segmented(const VertexBuffer& vertexBuffer, class Drawable { public: - template + template Drawable(DepthMode depthMode_, StencilMode stencilMode_, ColorMode colorMode_, - Shader& shader, - typename Shader::UniformsType::Values&& uniformValues, + Program& program_, + typename Program::UniformValues&& uniformValues, const Subject& subject) : drawMode(subject.drawMode), depthMode(std::move(depthMode_)), stencilMode(std::move(stencilMode_)), colorMode(std::move(colorMode_)), - program(shader.getID()), + program(program_.program), vertexBuffer(subject.vertexBuffer), vertexSize(subject.vertexSize), indexBuffer(subject.indexBuffer), primitiveSize(subject.primitiveSize), segments(subject.segments), - bindUniforms(Shader::UniformsType::binder(shader.uniformsState, std::move(uniformValues))), - bindAttributes(Shader::AttributesType::binder(shader.attributesState)) + bindUniforms(Program::Uniforms::binder(program_.uniformsState, std::move(uniformValues))), + bindAttributes(Program::Attributes::binder(program_.attributesState)) { - static_assert(std::is_standard_layout::value, "vertex type must use standard layout"); - static_assert(std::is_same::value, "vertex type mismatch"); + static_assert(std::is_standard_layout::value, "vertex type must use standard layout"); + static_assert(std::is_same::value, "vertex type mismatch"); } DrawMode drawMode; diff --git a/src/mbgl/gl/program.hpp b/src/mbgl/gl/program.hpp new file mode 100644 index 0000000000..ea4dbcc1df --- /dev/null +++ b/src/mbgl/gl/program.hpp @@ -0,0 +1,37 @@ +#pragma once + +#include +#include +#include + +#include + +namespace mbgl { +namespace gl { + +template +class Program { +public: + using Attributes = As; + using Vertex = typename Attributes::Vertex; + + using Uniforms = Us; + using UniformValues = typename Uniforms::Values; + + Program(Context& context, const std::string& vertexSource, const std::string& fragmentSource) + : vertexShader(context.createShader(ShaderType::Vertex, vertexSource)), + fragmentShader(context.createShader(ShaderType::Fragment, fragmentSource)), + program(context.createProgram(vertexShader, fragmentShader)), + attributesState(Attributes::state(program)), + uniformsState(Uniforms::state(program)) {} + + UniqueShader vertexShader; + UniqueShader fragmentShader; + UniqueProgram program; + + typename Attributes::State attributesState; + typename Uniforms::State uniformsState; +}; + +} // namespace gl +} // namespace mbgl diff --git a/src/mbgl/gl/shader.cpp b/src/mbgl/gl/shader.cpp deleted file mode 100644 index d8ee734567..0000000000 --- a/src/mbgl/gl/shader.cpp +++ /dev/null @@ -1,113 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include - -namespace mbgl { -namespace gl { - -Shader::Shader(const char* name_, - const char* vertexSource, - const char* fragmentSource, - Context& context, - Defines defines) - : name(name_), - program(context.createProgram()), - vertexShader(context.createVertexShader()), - fragmentShader(context.createFragmentShader()) { - util::stopwatch stopwatch("shader compilation", Event::Shader); - - 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"); - } - - 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"); - } - - // Attach shaders - 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())); - - 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(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()); - } -} - -bool Shader::compileShader(UniqueShader& shader, const GLchar *source) { - GLint status = 0; - - const GLsizei lengths = static_cast(std::strlen(source)); - MBGL_CHECK_ERROR(glShaderSource(shader.get(), 1, &source, &lengths)); - - MBGL_CHECK_ERROR(glCompileShader(shader.get())); - - MBGL_CHECK_ERROR(glGetShaderiv(shader.get(), GL_COMPILE_STATUS, &status)); - if (status == 0) { - GLint logLength; - MBGL_CHECK_ERROR(glGetShaderiv(shader.get(), GL_INFO_LOG_LENGTH, &logLength)); - if (logLength > 0) { - const auto log = std::make_unique(logLength); - MBGL_CHECK_ERROR(glGetShaderInfoLog(shader.get(), logLength, &logLength, log.get())); - Log::Error(Event::Shader, "Shader failed to compile: %s", log.get()); - } - return false; - } - - MBGL_CHECK_ERROR(glGetShaderiv(shader.get(), GL_COMPILE_STATUS, &status)); - if (status == GL_FALSE) { - Log::Error(Event::Shader, "Shader %s failed to compile.", name); - return false; - } - - return true; -} - -Shader::~Shader() { - if (program.get()) { - MBGL_CHECK_ERROR(glDetachShader(program.get(), vertexShader.get())); - MBGL_CHECK_ERROR(glDetachShader(program.get(), fragmentShader.get())); - } -} - -UniformLocation Shader::getUniformLocation(const char* uniform) const { - return MBGL_CHECK_ERROR(glGetUniformLocation(program.get(), uniform)); -} - -AttributeLocation Shader::getAttributeLocation(const char* attribute) const { - return MBGL_CHECK_ERROR(glGetAttribLocation(program.get(), attribute)); -} - -} // namespace gl -} // namespace mbgl diff --git a/src/mbgl/gl/shader.hpp b/src/mbgl/gl/shader.hpp deleted file mode 100644 index f88bd4f867..0000000000 --- a/src/mbgl/gl/shader.hpp +++ /dev/null @@ -1,45 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { -namespace gl { - -class Context; - -class Shader : private util::noncopyable { -public: - ~Shader(); - const char* name; - - ProgramID getID() const { - return program.get(); - } - - AttributeLocation getAttributeLocation(const char* uniform) const; - UniformLocation getUniformLocation(const char* uniform) const; - - enum Defines : bool { - None = false, - Overdraw = true, - }; - -protected: - Shader(const char* name_, - const char* vertex, - const char* fragment, - Context&, - Defines defines = Defines::None); - -private: - bool compileShader(UniqueShader&, const char *source); - - UniqueProgram program; - UniqueShader vertexShader; - UniqueShader fragmentShader; -}; - -} // namespace gl -} // namespace mbgl diff --git a/src/mbgl/gl/types.hpp b/src/mbgl/gl/types.hpp index 1697656469..577629d5d3 100644 --- a/src/mbgl/gl/types.hpp +++ b/src/mbgl/gl/types.hpp @@ -19,6 +19,11 @@ using AttributeLocation = int32_t; using UniformLocation = int32_t; using TextureUnit = uint8_t; +enum class ShaderType : uint32_t { + Vertex = 0x8B31, + Fragment = 0x8B30 +}; + enum class DataType : uint32_t { Byte = 0x1400, UnsignedByte = 0x1401, diff --git a/src/mbgl/gl/uniform.cpp b/src/mbgl/gl/uniform.cpp index 8018953fb5..7b674f2cde 100644 --- a/src/mbgl/gl/uniform.cpp +++ b/src/mbgl/gl/uniform.cpp @@ -7,6 +7,10 @@ namespace mbgl { namespace gl { +UniformLocation uniformLocation(ProgramID id, const char* name) { + return MBGL_CHECK_ERROR(glGetUniformLocation(id, name)); +} + template <> void bindUniform(UniformLocation location, const float& t) { MBGL_CHECK_ERROR(glUniform1f(location, t)); diff --git a/src/mbgl/gl/uniform.hpp b/src/mbgl/gl/uniform.hpp index 40a48d3af3..90ca16e46f 100644 --- a/src/mbgl/gl/uniform.hpp +++ b/src/mbgl/gl/uniform.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include #include #include @@ -27,9 +27,6 @@ public: class State { public: - State(const char* name, const Shader& shader) - : location(shader.getUniformLocation(name)) {} - void operator=(const Value& value) { if (!current || *current != value.t) { current = value.t; @@ -37,9 +34,8 @@ public: } } - private: - optional current; UniformLocation location; + optional current = {}; }; }; @@ -61,14 +57,16 @@ using UniformMatrix = Uniform>; #define MBGL_DEFINE_UNIFORM_MATRIX(type_, n_, name_) \ struct name_ : ::mbgl::gl::UniformMatrix { static constexpr auto name = #name_; } +UniformLocation uniformLocation(ProgramID, const char * name); + template class Uniforms { public: using State = std::tuple; using Values = std::tuple; - static State state(const Shader& shader) { - return State { { Us::name, shader }... }; + static State state(const ProgramID& id) { + return State { { uniformLocation(id, Us::name) }... }; } static std::function binder(State& state, Values&& values_) { diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp index 3fa58e016f..c2f8426785 100644 --- a/src/mbgl/layout/symbol_layout.cpp +++ b/src/mbgl/layout/symbol_layout.cpp @@ -507,14 +507,14 @@ void SymbolLayout::addToDebugBuffers(CollisionTile& collisionTile, SymbolBucket& const float maxZoom = util::clamp(zoom + util::log2(box.maxScale), util::MIN_ZOOM_F, util::MAX_ZOOM_F); const float placementZoom = util::clamp(zoom + util::log2(box.placementScale), util::MIN_ZOOM_F, util::MAX_ZOOM_F); - collisionBox.vertices.emplace_back(CollisionBoxAttributes::vertex(anchor, tl, maxZoom, placementZoom)); - collisionBox.vertices.emplace_back(CollisionBoxAttributes::vertex(anchor, tr, maxZoom, placementZoom)); - collisionBox.vertices.emplace_back(CollisionBoxAttributes::vertex(anchor, tr, maxZoom, placementZoom)); - collisionBox.vertices.emplace_back(CollisionBoxAttributes::vertex(anchor, br, maxZoom, placementZoom)); - collisionBox.vertices.emplace_back(CollisionBoxAttributes::vertex(anchor, br, maxZoom, placementZoom)); - collisionBox.vertices.emplace_back(CollisionBoxAttributes::vertex(anchor, bl, maxZoom, placementZoom)); - collisionBox.vertices.emplace_back(CollisionBoxAttributes::vertex(anchor, bl, maxZoom, placementZoom)); - collisionBox.vertices.emplace_back(CollisionBoxAttributes::vertex(anchor, tl, maxZoom, placementZoom)); + collisionBox.vertices.emplace_back(CollisionBoxProgram::vertex(anchor, tl, maxZoom, placementZoom)); + collisionBox.vertices.emplace_back(CollisionBoxProgram::vertex(anchor, tr, maxZoom, placementZoom)); + collisionBox.vertices.emplace_back(CollisionBoxProgram::vertex(anchor, tr, maxZoom, placementZoom)); + collisionBox.vertices.emplace_back(CollisionBoxProgram::vertex(anchor, br, maxZoom, placementZoom)); + collisionBox.vertices.emplace_back(CollisionBoxProgram::vertex(anchor, br, maxZoom, placementZoom)); + collisionBox.vertices.emplace_back(CollisionBoxProgram::vertex(anchor, bl, maxZoom, placementZoom)); + collisionBox.vertices.emplace_back(CollisionBoxProgram::vertex(anchor, bl, maxZoom, placementZoom)); + collisionBox.vertices.emplace_back(CollisionBoxProgram::vertex(anchor, tl, maxZoom, placementZoom)); } }; populateCollisionBox(symbolInstance.textCollisionFeature); diff --git a/src/mbgl/programs/attributes.hpp b/src/mbgl/programs/attributes.hpp new file mode 100644 index 0000000000..38bbe89377 --- /dev/null +++ b/src/mbgl/programs/attributes.hpp @@ -0,0 +1,23 @@ +#pragma once + +#include + +#include + +namespace mbgl { +namespace attributes { + +// Attributes common to several shaders. + +MBGL_DEFINE_ATTRIBUTE(int16_t, 2, a_pos); +MBGL_DEFINE_ATTRIBUTE(int16_t, 2, a_offset); +MBGL_DEFINE_ATTRIBUTE(int16_t, 2, a_extrude); +MBGL_DEFINE_ATTRIBUTE(uint16_t, 2, a_texture_pos); + +template +struct a_data : gl::Attribute, uint8_t, N> { + static constexpr auto name = "a_data"; +}; + +} // namespace attributes +} // namespace mbgl diff --git a/src/mbgl/programs/circle_program.cpp b/src/mbgl/programs/circle_program.cpp new file mode 100644 index 0000000000..d6bc439feb --- /dev/null +++ b/src/mbgl/programs/circle_program.cpp @@ -0,0 +1,7 @@ +#include + +namespace mbgl { + +static_assert(sizeof(CircleProgram::Vertex) == 4, "expected CircleVertex size"); + +} // namespace mbgl diff --git a/src/mbgl/programs/circle_program.hpp b/src/mbgl/programs/circle_program.hpp new file mode 100644 index 0000000000..690608a438 --- /dev/null +++ b/src/mbgl/programs/circle_program.hpp @@ -0,0 +1,52 @@ +#pragma once + +#include +#include +#include +#include +#include + +namespace mbgl { + +namespace uniforms { +MBGL_DEFINE_UNIFORM_SCALAR(float, u_radius); +MBGL_DEFINE_UNIFORM_SCALAR(bool, u_scale_with_map); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_devicepixelratio); +} // namespace uniforms + +class CircleProgram : public Program< + shaders::circle, + gl::Attributes< + attributes::a_pos>, + gl::Uniforms< + uniforms::u_matrix, + uniforms::u_opacity, + uniforms::u_color, + uniforms::u_radius, + uniforms::u_blur, + uniforms::u_scale_with_map, + uniforms::u_extrude_scale, + uniforms::u_devicepixelratio>> +{ +public: + using Program::Program; + + /* + * @param {number} x vertex position + * @param {number} y vertex position + * @param {number} ex extrude normal + * @param {number} ey extrude normal + */ + static Vertex vertex(Point p, float ex, float ey) { + return Vertex { + { + static_cast((p.x * 2) + ((ex + 1) / 2)), + static_cast((p.y * 2) + ((ey + 1) / 2)) + } + }; + } +}; + +using CircleVertex = CircleProgram::Vertex; + +} // namespace mbgl diff --git a/src/mbgl/programs/collision_box_program.cpp b/src/mbgl/programs/collision_box_program.cpp new file mode 100644 index 0000000000..d6a36e54a1 --- /dev/null +++ b/src/mbgl/programs/collision_box_program.cpp @@ -0,0 +1,7 @@ +#include + +namespace mbgl { + +static_assert(sizeof(CollisionBoxProgram::Vertex) == 10, "expected CollisionBoxVertex size"); + +} // namespace mbgl diff --git a/src/mbgl/programs/collision_box_program.hpp b/src/mbgl/programs/collision_box_program.hpp new file mode 100644 index 0000000000..66b1284621 --- /dev/null +++ b/src/mbgl/programs/collision_box_program.hpp @@ -0,0 +1,53 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include + +namespace mbgl { + +namespace uniforms { +MBGL_DEFINE_UNIFORM_SCALAR(float, u_scale); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_maxzoom); +} // namespace uniforms + +class CollisionBoxProgram : public Program< + shaders::collision_box, + gl::Attributes< + attributes::a_pos, + attributes::a_extrude, + attributes::a_data<2>>, + gl::Uniforms< + uniforms::u_matrix, + uniforms::u_scale, + uniforms::u_zoom, + uniforms::u_maxzoom>> +{ +public: + using Program::Program; + + static Vertex vertex(Point a, Point o, float maxzoom, float placementZoom) { + return Vertex { + { + static_cast(a.x), + static_cast(a.y) + }, + { + static_cast(::round(o.x)), + static_cast(::round(o.y)) + }, + { + static_cast(maxzoom * 10), + static_cast(placementZoom * 10) + } + }; + } +}; + +using CollisionBoxVertex = CollisionBoxProgram::Vertex; + +} // namespace mbgl diff --git a/src/mbgl/programs/fill_program.cpp b/src/mbgl/programs/fill_program.cpp new file mode 100644 index 0000000000..90c09a995c --- /dev/null +++ b/src/mbgl/programs/fill_program.cpp @@ -0,0 +1,47 @@ +#include +#include +#include +#include +#include + +namespace mbgl { + +using namespace style; + +static_assert(sizeof(FillAttributes::Vertex) == 4, "expected FillVertex size"); + +FillPatternUniforms::Values +FillPatternUniforms::values(mat4 matrix, + float opacity, + Size framebufferSize, + const SpriteAtlasPosition& a, + const SpriteAtlasPosition& b, + const Faded& fading, + const UnwrappedTileID& tileID, + const TransformState& state) +{ + int32_t tileSizeAtNearestZoom = util::tileSize * state.zoomScale(state.getIntegerZoom() - tileID.canonical.z); + int32_t pixelX = tileSizeAtNearestZoom * (tileID.canonical.x + tileID.wrap * state.zoomScale(tileID.canonical.z)); + int32_t pixelY = tileSizeAtNearestZoom * tileID.canonical.y; + + return FillPatternUniforms::Values { + uniforms::u_matrix::Value{ matrix }, + uniforms::u_opacity::Value{ opacity }, + uniforms::u_world::Value{ framebufferSize }, + uniforms::u_pattern_tl_a::Value{ a.tl }, + uniforms::u_pattern_br_a::Value{ a.br }, + uniforms::u_pattern_tl_b::Value{ b.tl }, + uniforms::u_pattern_br_b::Value{ b.br }, + uniforms::u_pattern_size_a::Value{ a.size }, + uniforms::u_pattern_size_b::Value{ b.size }, + uniforms::u_scale_a::Value{ fading.fromScale }, + uniforms::u_scale_b::Value{ fading.toScale }, + uniforms::u_mix::Value{ fading.t }, + uniforms::u_image::Value{ 0 }, + uniforms::u_pixel_coord_upper::Value{ std::array {{ float(pixelX >> 16), float(pixelY >> 16) }} }, + uniforms::u_pixel_coord_lower::Value{ std::array {{ float(pixelX & 0xFFFF), float(pixelY & 0xFFFF) }} }, + uniforms::u_tile_units_to_pixels::Value{ 1.0f / tileID.pixelsToTileUnits(1.0f, state.getIntegerZoom()) }, + }; +} + +} // namespace mbgl diff --git a/src/mbgl/programs/fill_program.hpp b/src/mbgl/programs/fill_program.hpp new file mode 100644 index 0000000000..3f738527c8 --- /dev/null +++ b/src/mbgl/programs/fill_program.hpp @@ -0,0 +1,119 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace mbgl { + +class SpriteAtlasPosition; +class UnwrappedTileID; +class TransformState; + +namespace style { +template class Faded; +} // namespace style + +namespace uniforms { +MBGL_DEFINE_UNIFORM_SCALAR(Size, u_world); +MBGL_DEFINE_UNIFORM_SCALAR(Color, u_outline_color); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_scale_a); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_scale_b); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_tile_units_to_pixels); +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pixel_coord_upper); +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pixel_coord_lower); +} // namespace uniforms + +struct FillAttributes : gl::Attributes< + attributes::a_pos> +{ + static Vertex vertex(Point p) { + return Vertex { + { + p.x, + p.y + } + }; + } +}; + +using FillVertex = FillAttributes::Vertex; + +struct FillUniforms : gl::Uniforms< + uniforms::u_matrix, + uniforms::u_opacity, + uniforms::u_color, + uniforms::u_outline_color, + uniforms::u_world> +{}; + +struct FillPatternUniforms : gl::Uniforms< + uniforms::u_matrix, + uniforms::u_opacity, + uniforms::u_world, + uniforms::u_pattern_tl_a, + uniforms::u_pattern_br_a, + uniforms::u_pattern_tl_b, + uniforms::u_pattern_br_b, + uniforms::u_pattern_size_a, + uniforms::u_pattern_size_b, + uniforms::u_scale_a, + uniforms::u_scale_b, + uniforms::u_mix, + uniforms::u_image, + uniforms::u_pixel_coord_upper, + uniforms::u_pixel_coord_lower, + uniforms::u_tile_units_to_pixels> +{ + static Values values(mat4 matrix, + float opacity, + Size framebufferSize, + const SpriteAtlasPosition&, + const SpriteAtlasPosition&, + const style::Faded&, + const UnwrappedTileID&, + const TransformState&); +}; + +class FillProgram : public Program< + shaders::fill, + FillAttributes, + FillUniforms> +{ + using Program::Program; +}; + +class FillPatternProgram : public Program< + shaders::fill_pattern, + FillAttributes, + FillPatternUniforms> +{ + using Program::Program; +}; + +class FillOutlineProgram : public Program< + shaders::fill_outline, + FillAttributes, + FillUniforms> +{ + using Program::Program; +}; + +class FillOutlinePatternProgram : public Program< + shaders::fill_outline_pattern, + FillAttributes, + FillPatternUniforms> +{ + using Program::Program; +}; + +} // namespace mbgl diff --git a/src/mbgl/programs/line_program.cpp b/src/mbgl/programs/line_program.cpp new file mode 100644 index 0000000000..07af464eb3 --- /dev/null +++ b/src/mbgl/programs/line_program.cpp @@ -0,0 +1,135 @@ +#include +#include +#include +#include +#include +#include +#include + +namespace mbgl { + +static_assert(sizeof(LineAttributes::Vertex) == 8, "expected LineVertex size"); + +template +Values makeValues(const style::LinePaintProperties& properties, + float pixelRatio, + const RenderTile& tile, + const TransformState& state, + Args&&... args) { + // the distance over which the line edge fades out. + // Retina devices need a smaller distance to avoid aliasing. + float antialiasing = 1.0 / pixelRatio; + + mat2 antialiasingMatrix; + matrix::identity(antialiasingMatrix); + matrix::scale(antialiasingMatrix, antialiasingMatrix, 1.0, std::cos(state.getPitch())); + matrix::rotate(antialiasingMatrix, antialiasingMatrix, state.getAngle()); + + // calculate how much longer the real world distance is at the top of the screen + // than at the middle of the screen. + float topedgelength = std::sqrt(std::pow(state.getSize().height, 2.0f) / 4.0f * (1.0f + std::pow(state.getAltitude(), 2.0f))); + float x = state.getSize().height / 2.0f * std::tan(state.getPitch()); + + return Values { + uniforms::u_matrix::Value{ tile.translatedMatrix(properties.lineTranslate.value, + properties.lineTranslateAnchor.value, + state) }, + uniforms::u_opacity::Value{ properties.lineOpacity.value }, + uniforms::u_linewidth::Value{ properties.lineWidth.value / 2 }, + uniforms::u_gapwidth::Value{ properties.lineGapWidth.value / 2 }, + uniforms::u_blur::Value{ properties.lineBlur.value + antialiasing }, + uniforms::u_offset::Value{ -properties.lineOffset.value }, + uniforms::u_antialiasing::Value{ antialiasing / 2 }, + uniforms::u_antialiasingmatrix::Value{ antialiasingMatrix }, + uniforms::u_ratio::Value{ 1.0f / tile.id.pixelsToTileUnits(1.0, state.getZoom()) }, + uniforms::u_extra::Value{ (topedgelength + x) / topedgelength - 1.0f }, + std::forward(args)... + }; +} + +LineProgram::UniformValues +LineProgram::uniformValues(const style::LinePaintProperties& properties, + float pixelRatio, + const RenderTile& tile, + const TransformState& state) { + return makeValues( + properties, + pixelRatio, + tile, + state, + uniforms::u_color::Value{ properties.lineColor.value } + ); +} + +LineSDFProgram::UniformValues +LineSDFProgram::uniformValues(const style::LinePaintProperties& properties, + float pixelRatio, + const RenderTile& tile, + const TransformState& state, + const LinePatternPos& posA, + const LinePatternPos& posB, + float dashLineWidth, + float atlasWidth) { + const float widthA = posA.width * properties.lineDasharray.value.fromScale * dashLineWidth; + const float widthB = posB.width * properties.lineDasharray.value.toScale * dashLineWidth; + + std::array scaleA {{ + 1.0f / tile.id.pixelsToTileUnits(widthA, state.getIntegerZoom()), + -posA.height / 2.0f + }}; + + std::array scaleB {{ + 1.0f / tile.id.pixelsToTileUnits(widthB, state.getIntegerZoom()), + -posB.height / 2.0f + }}; + + return makeValues( + properties, + pixelRatio, + tile, + state, + uniforms::u_color::Value{ properties.lineColor.value }, + uniforms::u_patternscale_a::Value{ scaleA }, + uniforms::u_patternscale_b::Value{ scaleB }, + uniforms::u_tex_y_a::Value{ posA.y }, + uniforms::u_tex_y_b::Value{ posB.y }, + uniforms::u_mix::Value{ properties.lineDasharray.value.t }, + uniforms::u_sdfgamma::Value{ atlasWidth / (std::min(widthA, widthB) * 256.0f * pixelRatio) / 2.0f }, + uniforms::u_image::Value{ 0 } + ); +} + +LinePatternProgram::UniformValues +LinePatternProgram::uniformValues(const style::LinePaintProperties& properties, + float pixelRatio, + const RenderTile& tile, + const TransformState& state, + const SpriteAtlasPosition& posA, + const SpriteAtlasPosition& posB) { + std::array sizeA {{ + tile.id.pixelsToTileUnits(posA.size[0] * properties.linePattern.value.fromScale, state.getIntegerZoom()), + posA.size[1] + }}; + + std::array sizeB {{ + tile.id.pixelsToTileUnits(posB.size[0] * properties.linePattern.value.toScale, state.getIntegerZoom()), + posB.size[1] + }}; + + return makeValues( + properties, + pixelRatio, + tile, + state, + uniforms::u_pattern_tl_a::Value{ posA.tl }, + uniforms::u_pattern_br_a::Value{ posA.br }, + uniforms::u_pattern_tl_b::Value{ posB.tl }, + uniforms::u_pattern_br_b::Value{ posB.br }, + uniforms::u_pattern_size_a::Value{ sizeA }, + uniforms::u_pattern_size_b::Value{ sizeB }, + uniforms::u_fade::Value{ properties.linePattern.value.t }, + uniforms::u_image::Value{ 0 } + ); +} + +} // namespace mbgl diff --git a/src/mbgl/programs/line_program.hpp b/src/mbgl/programs/line_program.hpp new file mode 100644 index 0000000000..960438f4cd --- /dev/null +++ b/src/mbgl/programs/line_program.hpp @@ -0,0 +1,184 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace mbgl { + +namespace style { +class LinePaintProperties; +} // namespace style + +class RenderTile; +class TransformState; +class LinePatternPos; +class SpriteAtlasPosition; + +namespace uniforms { +MBGL_DEFINE_UNIFORM_SCALAR(float, u_ratio); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_linewidth); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_gapwidth); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_antialiasing); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_extra); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_offset); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_tex_y_a); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_tex_y_b); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_sdfgamma); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_fade); +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_patternscale_a); +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_patternscale_b); +MBGL_DEFINE_UNIFORM_MATRIX(double, 2, u_antialiasingmatrix); +} // namespace uniforms + +struct LineAttributes : gl::Attributes< + attributes::a_pos, + attributes::a_data<4>> +{ + /* + * @param p vertex position + * @param e extrude normal + * @param t texture normal + * @param dir direction of the line cap (-1/0/1) + */ + static Vertex vertex(Point p, Point e, Point t, int8_t dir, int32_t linesofar = 0) { + return Vertex { + { + static_cast((p.x * 2) | t.x), + static_cast((p.y * 2) | t.y) + }, + { + // add 128 to store an byte in an unsigned byte + static_cast(::round(extrudeScale * e.x) + 128), + static_cast(::round(extrudeScale * e.y) + 128), + + // Encode the -1/0/1 direction value into the first two bits of .z of a_data. + // Combine it with the lower 6 bits of `linesofar` (shifted by 2 bites to make + // room for the direction value). The upper 8 bits of `linesofar` are placed in + // the `w` component. `linesofar` is scaled down by `LINE_DISTANCE_SCALE` so that + // we can store longer distances while sacrificing precision. + + // Encode the -1/0/1 direction value into .zw coordinates of a_data, which is normally covered + // by linesofar, so we need to merge them. + // The z component's first bit, as well as the sign bit is reserved for the direction, + // so we need to shift the linesofar. + static_cast(((dir == 0 ? 0 : (dir < 0 ? -1 : 1 )) + 1) | ((linesofar & 0x3F) << 2)), + static_cast(linesofar >> 6) + } + }; + } + + /* + * Scale the extrusion vector so that the normal length is this value. + * Contains the "texture" normals (-1..1). This is distinct from the extrude + * normals for line joins, because the x-value remains 0 for the texture + * normal array, while the extrude normal actually moves the vertex to create + * the acute/bevelled line join. + */ + static const int8_t extrudeScale = 63; +}; + +using LineVertex = LineAttributes::Vertex; + +class LineProgram : public Program< + shaders::line, + LineAttributes, + gl::Uniforms< + uniforms::u_matrix, + uniforms::u_opacity, + uniforms::u_linewidth, + uniforms::u_gapwidth, + uniforms::u_blur, + uniforms::u_offset, + uniforms::u_antialiasing, + uniforms::u_antialiasingmatrix, + uniforms::u_ratio, + uniforms::u_extra, + uniforms::u_color>> +{ +public: + using Program::Program; + + static UniformValues uniformValues(const style::LinePaintProperties&, + float pixelRatio, + const RenderTile&, + const TransformState&); +}; + +class LinePatternProgram : public Program< + shaders::line_pattern, + LineAttributes, + gl::Uniforms< + uniforms::u_matrix, + uniforms::u_opacity, + uniforms::u_linewidth, + uniforms::u_gapwidth, + uniforms::u_blur, + uniforms::u_offset, + uniforms::u_antialiasing, + uniforms::u_antialiasingmatrix, + uniforms::u_ratio, + uniforms::u_extra, + uniforms::u_pattern_tl_a, + uniforms::u_pattern_br_a, + uniforms::u_pattern_tl_b, + uniforms::u_pattern_br_b, + uniforms::u_pattern_size_a, + uniforms::u_pattern_size_b, + uniforms::u_fade, + uniforms::u_image>> +{ +public: + using Program::Program; + + static UniformValues uniformValues(const style::LinePaintProperties&, + float pixelRatio, + const RenderTile&, + const TransformState&, + const SpriteAtlasPosition& posA, + const SpriteAtlasPosition& posB); +}; + +class LineSDFProgram : public Program< + shaders::line_sdf, + LineAttributes, + gl::Uniforms< + uniforms::u_matrix, + uniforms::u_opacity, + uniforms::u_linewidth, + uniforms::u_gapwidth, + uniforms::u_blur, + uniforms::u_offset, + uniforms::u_antialiasing, + uniforms::u_antialiasingmatrix, + uniforms::u_ratio, + uniforms::u_extra, + uniforms::u_color, + uniforms::u_patternscale_a, + uniforms::u_patternscale_b, + uniforms::u_tex_y_a, + uniforms::u_tex_y_b, + uniforms::u_mix, + uniforms::u_sdfgamma, + uniforms::u_image>> +{ +public: + using Program::Program; + + static UniformValues uniformValues(const style::LinePaintProperties&, + float pixelRatio, + const RenderTile&, + const TransformState&, + const LinePatternPos& posA, + const LinePatternPos& posB, + float dashLineWidth, + float atlasWidth); +}; + +} // namespace mbgl diff --git a/src/mbgl/programs/program.hpp b/src/mbgl/programs/program.hpp new file mode 100644 index 0000000000..9f154b051a --- /dev/null +++ b/src/mbgl/programs/program.hpp @@ -0,0 +1,31 @@ +#pragma once + +#include + +#include + +namespace mbgl { + +enum class ProgramDefines : bool { + None = false, + Overdraw = true, +}; + +template +class Program : public gl::Program { +public: + Program(gl::Context& context, ProgramDefines defines) + : gl::Program(context, Shaders::vertexSource, fragmentSource(defines)) + {} + + static std::string fragmentSource(ProgramDefines defines) { + std::string fragment = Shaders::fragmentSource; + if (defines == ProgramDefines::Overdraw) { + assert(fragment.find("#ifdef OVERDRAW_INSPECTOR") != std::string::npos); + fragment.replace(fragment.find_first_of('\n'), 1, "\n#define OVERDRAW_INSPECTOR\n"); + } + return fragment; + } +}; + +} // namespace mbgl diff --git a/src/mbgl/programs/programs.hpp b/src/mbgl/programs/programs.hpp new file mode 100644 index 0000000000..aebafaec62 --- /dev/null +++ b/src/mbgl/programs/programs.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace mbgl { + +class Programs { +public: + Programs(gl::Context& context, ProgramDefines defines = ProgramDefines::None) + : circle(context, defines), + fill(context, defines), + fillPattern(context, defines), + fillOutline(context, defines), + fillOutlinePattern(context, defines), + line(context, defines), + lineSDF(context, defines), + linePattern(context, defines), + raster(context, defines), + symbolIcon(context, defines), + symbolIconSDF(context, defines), + symbolGlyph(context, defines), + collisionBox(context, ProgramDefines::None) { + } + + CircleProgram circle; + FillProgram fill; + FillPatternProgram fillPattern; + FillOutlineProgram fillOutline; + FillOutlinePatternProgram fillOutlinePattern; + LineProgram line; + LineSDFProgram lineSDF; + LinePatternProgram linePattern; + RasterProgram raster; + SymbolIconProgram symbolIcon; + SymbolSDFProgram symbolIconSDF; + SymbolSDFProgram symbolGlyph; + + CollisionBoxProgram collisionBox; +}; + +} // namespace mbgl diff --git a/src/mbgl/programs/raster_program.cpp b/src/mbgl/programs/raster_program.cpp new file mode 100644 index 0000000000..ebec4c68cc --- /dev/null +++ b/src/mbgl/programs/raster_program.cpp @@ -0,0 +1,7 @@ +#include + +namespace mbgl { + +static_assert(sizeof(RasterProgram::Vertex) == 8, "expected RasterVertex size"); + +} // namespace mbgl diff --git a/src/mbgl/programs/raster_program.hpp b/src/mbgl/programs/raster_program.hpp new file mode 100644 index 0000000000..1e9a0cdb6a --- /dev/null +++ b/src/mbgl/programs/raster_program.hpp @@ -0,0 +1,65 @@ +#pragma once + +#include +#include +#include +#include +#include + +namespace mbgl { + +namespace uniforms { +MBGL_DEFINE_UNIFORM_SCALAR(gl::TextureUnit, u_image0); +MBGL_DEFINE_UNIFORM_SCALAR(gl::TextureUnit, u_image1); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_opacity0); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_opacity1); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_buffer_scale); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_brightness_low); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_brightness_high); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_saturation_factor); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_contrast_factor); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_scale_parent); +MBGL_DEFINE_UNIFORM_VECTOR(float, 3, u_spin_weights); +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_tl_parent); +} // namespace uniforms + +class RasterProgram : public Program< + shaders::raster, + gl::Attributes< + attributes::a_pos, + attributes::a_texture_pos>, + gl::Uniforms< + uniforms::u_matrix, + uniforms::u_image0, + uniforms::u_image1, + uniforms::u_opacity0, + uniforms::u_opacity1, + uniforms::u_brightness_low, + uniforms::u_brightness_high, + uniforms::u_saturation_factor, + uniforms::u_contrast_factor, + uniforms::u_spin_weights, + uniforms::u_buffer_scale, + uniforms::u_scale_parent, + uniforms::u_tl_parent>> +{ +public: + using Program::Program; + + static Vertex vertex(Point p, Point t) { + return Vertex { + { + p.x, + p.y + }, + { + t.x, + t.y + } + }; + } +}; + +using RasterVertex = RasterProgram::Vertex; + +} // namespace mbgl diff --git a/src/mbgl/programs/symbol_program.cpp b/src/mbgl/programs/symbol_program.cpp new file mode 100644 index 0000000000..8c9c34210c --- /dev/null +++ b/src/mbgl/programs/symbol_program.cpp @@ -0,0 +1,145 @@ +#include +#include +#include +#include + +namespace mbgl { + +using namespace style; + +static_assert(sizeof(SymbolAttributes::Vertex) == 16, "expected SymbolVertex size"); + +template +Values makeValues(const style::SymbolPropertyValues& values, + const Size& texsize, + const std::array& pixelsToGLUnits, + const RenderTile& tile, + const TransformState& state, + Args&&... args) { + std::array extrudeScale; + + const float scale = values.paintSize / values.sdfScale; + if (values.pitchAlignment == AlignmentType::Map) { + extrudeScale.fill(tile.id.pixelsToTileUnits(1, state.getZoom()) * scale); + } else { + extrudeScale = {{ + pixelsToGLUnits[0] * scale * state.getAltitude(), + pixelsToGLUnits[1] * scale * state.getAltitude() + }}; + } + + // adjust min/max zooms for variable font sies + float zoomAdjust = std::log(values.paintSize / values.layoutSize) / std::log(2); + + return Values { + uniforms::u_matrix::Value{ tile.translatedMatrix(values.translate, + values.translateAnchor, + state) }, + uniforms::u_opacity::Value{ values.opacity }, + uniforms::u_extrude_scale::Value{ extrudeScale }, + uniforms::u_texsize::Value{ std::array {{ float(texsize.width) / 4, float(texsize.height) / 4 }} }, + uniforms::u_zoom::Value{ float((state.getZoom() - zoomAdjust) * 10) }, + uniforms::u_rotate_with_map::Value{ values.rotationAlignment == AlignmentType::Map }, + uniforms::u_texture::Value{ 0 }, + uniforms::u_fadetexture::Value{ 1 }, + std::forward(args)... + }; +} + +SymbolIconProgram::UniformValues +SymbolIconProgram::uniformValues(const style::SymbolPropertyValues& values, + const Size& texsize, + const std::array& pixelsToGLUnits, + const RenderTile& tile, + const TransformState& state) +{ + return makeValues( + values, + texsize, + pixelsToGLUnits, + tile, + state + ); +} + +static SymbolSDFProgram::UniformValues makeSDFValues(const style::SymbolPropertyValues& values, + const Size& texsize, + const std::array& pixelsToGLUnits, + const RenderTile& tile, + const TransformState& state, + float pixelRatio, + Color color, + float buffer, + float gammaAdjust) +{ + // The default gamma value has to be adjust for the current pixelratio so that we're not + // drawing blurry font on retina screens. + const float gammaBase = 0.105 * values.sdfScale / values.paintSize / pixelRatio; + const float gammaScale = values.pitchAlignment == AlignmentType::Map + ? 1.0 / std::cos(state.getPitch()) + : 1.0; + + return makeValues( + values, + texsize, + pixelsToGLUnits, + tile, + state, + uniforms::u_color::Value{ color }, + uniforms::u_buffer::Value{ buffer }, + uniforms::u_gamma::Value{ (gammaBase + gammaAdjust) * gammaScale }, + uniforms::u_pitch::Value{ state.getPitch() }, + uniforms::u_bearing::Value{ -1.0f * state.getAngle() }, + uniforms::u_aspect_ratio::Value{ (state.getSize().width * 1.0f) / (state.getSize().height * 1.0f) }, + uniforms::u_pitch_with_map::Value{ values.pitchAlignment == AlignmentType::Map } + ); +} + +SymbolSDFProgram::UniformValues +SymbolSDFProgram::haloUniformValues(const style::SymbolPropertyValues& values, + const Size& texsize, + const std::array& pixelsToGLUnits, + const RenderTile& tile, + const TransformState& state, + float pixelRatio) +{ + const float scale = values.paintSize / values.sdfScale; + const float sdfPx = 8.0f; + const float blurOffset = 1.19f; + const float haloOffset = 6.0f; + + return makeSDFValues( + values, + texsize, + pixelsToGLUnits, + tile, + state, + pixelRatio, + values.haloColor, + (haloOffset - values.haloWidth / scale) / sdfPx, + values.haloBlur * blurOffset / scale / sdfPx + ); +} + +SymbolSDFProgram::UniformValues +SymbolSDFProgram::foregroundUniformValues(const style::SymbolPropertyValues& values, + const Size& texsize, + const std::array& pixelsToGLUnits, + const RenderTile& tile, + const TransformState& state, + float pixelRatio) +{ + return makeSDFValues( + values, + texsize, + pixelsToGLUnits, + tile, + state, + pixelRatio, + values.color, + (256.0f - 64.0f) / 256.0f, + 0 + ); +} + +} // namespace mbgl diff --git a/src/mbgl/programs/symbol_program.hpp b/src/mbgl/programs/symbol_program.hpp new file mode 100644 index 0000000000..eb8c56b326 --- /dev/null +++ b/src/mbgl/programs/symbol_program.hpp @@ -0,0 +1,134 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +namespace mbgl { + +namespace style { +class SymbolPropertyValues; +} // namespace style + +class RenderTile; +class TransformState; + +namespace uniforms { +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_texsize); +MBGL_DEFINE_UNIFORM_SCALAR(bool, u_rotate_with_map); +MBGL_DEFINE_UNIFORM_SCALAR(bool, u_pitch_with_map); +MBGL_DEFINE_UNIFORM_SCALAR(gl::TextureUnit, u_texture); +MBGL_DEFINE_UNIFORM_SCALAR(gl::TextureUnit, u_fadetexture); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_buffer); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_gamma); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_aspect_ratio); +} // namespace uniforms + +struct SymbolAttributes : gl::Attributes< + attributes::a_pos, + attributes::a_offset, + attributes::a_texture_pos, + attributes::a_data<4>> +{ + static Vertex vertex(Point a, + Point o, + uint16_t tx, + uint16_t ty, + float minzoom, + float maxzoom, + float labelminzoom, + uint8_t labelangle) { + return Vertex { + { + static_cast(a.x), + static_cast(a.y) + }, + { + static_cast(::round(o.x * 64)), // use 1/64 pixels for placement + static_cast(::round(o.y * 64)) + }, + { + static_cast(tx / 4), + static_cast(ty / 4) + }, + { + static_cast(labelminzoom * 10), // 1/10 zoom levels: z16 == 160 + static_cast(labelangle), + static_cast(minzoom * 10), + static_cast(::fmin(maxzoom, 25) * 10) + } + }; + } +}; + +using SymbolVertex = SymbolAttributes::Vertex; + +class SymbolIconProgram : public Program< + shaders::symbol_icon, + SymbolAttributes, + gl::Uniforms< + uniforms::u_matrix, + uniforms::u_opacity, + uniforms::u_extrude_scale, + uniforms::u_texsize, + uniforms::u_zoom, + uniforms::u_rotate_with_map, + uniforms::u_texture, + uniforms::u_fadetexture>> +{ +public: + using Program::Program; + + static UniformValues uniformValues(const style::SymbolPropertyValues&, + const Size& texsize, + const std::array& pixelsToGLUnits, + const RenderTile&, + const TransformState&); +}; + +class SymbolSDFProgram : public Program< + shaders::symbol_sdf, + SymbolAttributes, + gl::Uniforms< + uniforms::u_matrix, + uniforms::u_opacity, + uniforms::u_extrude_scale, + uniforms::u_texsize, + uniforms::u_zoom, + uniforms::u_rotate_with_map, + uniforms::u_texture, + uniforms::u_fadetexture, + uniforms::u_color, + uniforms::u_buffer, + uniforms::u_gamma, + uniforms::u_pitch, + uniforms::u_bearing, + uniforms::u_aspect_ratio, + uniforms::u_pitch_with_map>> +{ +public: + using Program::Program; + + static UniformValues haloUniformValues(const style::SymbolPropertyValues&, + const Size& texsize, + const std::array& pixelsToGLUnits, + const RenderTile&, + const TransformState&, + float pixelRatio); + + static UniformValues foregroundUniformValues(const style::SymbolPropertyValues&, + const Size& texsize, + const std::array& pixelsToGLUnits, + const RenderTile&, + const TransformState&, + float pixelRatio); +}; + +} // namespace mbgl diff --git a/src/mbgl/programs/uniforms.hpp b/src/mbgl/programs/uniforms.hpp new file mode 100644 index 0000000000..e0c5a0d361 --- /dev/null +++ b/src/mbgl/programs/uniforms.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include +#include + +namespace mbgl { +namespace uniforms { + +// Uniforms common to several shaders. + +MBGL_DEFINE_UNIFORM_MATRIX(double, 4, u_matrix); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_opacity); +MBGL_DEFINE_UNIFORM_SCALAR(Color, u_color); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_blur); + +MBGL_DEFINE_UNIFORM_SCALAR(float, u_zoom); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_pitch); +MBGL_DEFINE_UNIFORM_SCALAR(float, u_bearing); + +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_extrude_scale); + +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_tl_a); +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_br_a); +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_tl_b); +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_br_b); +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_size_a); +MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_size_b); + +MBGL_DEFINE_UNIFORM_SCALAR(float, u_mix); +MBGL_DEFINE_UNIFORM_SCALAR(gl::TextureUnit, u_image); + +} // namespace uniforms +} // namespace mbgl diff --git a/src/mbgl/renderer/circle_bucket.cpp b/src/mbgl/renderer/circle_bucket.cpp index 1137a3f5dc..08f2a144a1 100644 --- a/src/mbgl/renderer/circle_bucket.cpp +++ b/src/mbgl/renderer/circle_bucket.cpp @@ -2,7 +2,7 @@ #include #include -#include +#include #include #include @@ -58,10 +58,10 @@ void CircleBucket::addGeometry(const GeometryCollection& geometryCollection) { // │ 1 2 │ // └─────────┘ // - vertices.emplace_back(CircleAttributes::vertex(point, -1, -1)); // 1 - vertices.emplace_back(CircleAttributes::vertex(point, 1, -1)); // 2 - vertices.emplace_back(CircleAttributes::vertex(point, 1, 1)); // 3 - vertices.emplace_back(CircleAttributes::vertex(point, -1, 1)); // 4 + vertices.emplace_back(CircleProgram::vertex(point, -1, -1)); // 1 + vertices.emplace_back(CircleProgram::vertex(point, 1, -1)); // 2 + vertices.emplace_back(CircleProgram::vertex(point, 1, 1)); // 3 + vertices.emplace_back(CircleProgram::vertex(point, -1, 1)); // 4 auto& segment = segments.back(); assert(segment.vertexLength <= std::numeric_limits::max()); diff --git a/src/mbgl/renderer/circle_bucket.hpp b/src/mbgl/renderer/circle_bucket.hpp index b0ae47f523..d5df06f110 100644 --- a/src/mbgl/renderer/circle_bucket.hpp +++ b/src/mbgl/renderer/circle_bucket.hpp @@ -6,7 +6,7 @@ #include #include #include -#include +#include namespace mbgl { diff --git a/src/mbgl/renderer/debug_bucket.cpp b/src/mbgl/renderer/debug_bucket.cpp index d2d4465ab6..931d1bf30d 100644 --- a/src/mbgl/renderer/debug_bucket.cpp +++ b/src/mbgl/renderer/debug_bucket.cpp @@ -1,7 +1,6 @@ #include #include -#include -#include +#include #include #include diff --git a/src/mbgl/renderer/debug_bucket.hpp b/src/mbgl/renderer/debug_bucket.hpp index beb57fa51a..9b19e7f949 100644 --- a/src/mbgl/renderer/debug_bucket.hpp +++ b/src/mbgl/renderer/debug_bucket.hpp @@ -6,7 +6,7 @@ #include #include #include -#include +#include namespace mbgl { diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp index 97ba5c5f9e..2eee8f2d6d 100644 --- a/src/mbgl/renderer/fill_bucket.cpp +++ b/src/mbgl/renderer/fill_bucket.cpp @@ -1,10 +1,7 @@ #include #include #include -#include -#include -#include -#include +#include #include #include diff --git a/src/mbgl/renderer/fill_bucket.hpp b/src/mbgl/renderer/fill_bucket.hpp index c7f07b51e7..b2c549a758 100644 --- a/src/mbgl/renderer/fill_bucket.hpp +++ b/src/mbgl/renderer/fill_bucket.hpp @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include diff --git a/src/mbgl/renderer/line_bucket.hpp b/src/mbgl/renderer/line_bucket.hpp index 1123ddadb6..4d78a80123 100644 --- a/src/mbgl/renderer/line_bucket.hpp +++ b/src/mbgl/renderer/line_bucket.hpp @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include #include diff --git a/src/mbgl/renderer/paint_parameters.hpp b/src/mbgl/renderer/paint_parameters.hpp index bd67dc9cfd..213c01cfbd 100644 --- a/src/mbgl/renderer/paint_parameters.hpp +++ b/src/mbgl/renderer/paint_parameters.hpp @@ -2,12 +2,12 @@ namespace mbgl { -class Shaders; +class Programs; class View; class PaintParameters { public: - Shaders& shaders; + Programs& programs; View& view; }; diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp index 6777871516..d9e7f9fd35 100644 --- a/src/mbgl/renderer/painter.cpp +++ b/src/mbgl/renderer/painter.cpp @@ -21,7 +21,7 @@ #include #include -#include +#include #include #include @@ -60,18 +60,18 @@ Painter::Painter(gl::Context& context_, const TransformState& state_) FillAttributes::vertex({ 0, 0 }) }})), rasterVertexBuffer(context.createVertexBuffer(std::vector {{ - RasterAttributes::vertex({ 0, 0 }, { 0, 0 }), - RasterAttributes::vertex({ util::EXTENT, 0 }, { 32767, 0 }), - RasterAttributes::vertex({ 0, util::EXTENT }, { 0, 32767 }), - RasterAttributes::vertex({ util::EXTENT, util::EXTENT }, { 32767, 32767 }) + RasterProgram::vertex({ 0, 0 }, { 0, 0 }), + RasterProgram::vertex({ util::EXTENT, 0 }, { 32767, 0 }), + RasterProgram::vertex({ 0, util::EXTENT }, { 0, 32767 }), + RasterProgram::vertex({ util::EXTENT, util::EXTENT }, { 32767, 32767 }) }})) { #ifndef NDEBUG gl::debugging::enable(); #endif - shaders = std::make_unique(context); + programs = std::make_unique(context); #ifndef NDEBUG - overdrawShaders = std::make_unique(context, gl::Shader::Overdraw); + overdrawPrograms = std::make_unique(context, ProgramDefines::Overdraw); #endif } @@ -93,9 +93,9 @@ void Painter::render(const Style& style, const FrameData& frame_, View& view, Sp PaintParameters parameters { #ifndef NDEBUG - paintMode() == PaintMode::Overdraw ? *overdrawShaders : *shaders, + paintMode() == PaintMode::Overdraw ? *overdrawPrograms : *programs, #else - *shaders, + *programs, #endif view }; diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp index d7154397f3..53215c5033 100644 --- a/src/mbgl/renderer/painter.hpp +++ b/src/mbgl/renderer/painter.hpp @@ -9,8 +9,8 @@ #include #include -#include -#include +#include +#include #include @@ -40,8 +40,7 @@ class CircleBucket; class SymbolBucket; class RasterBucket; -class Shaders; -class SymbolSDFShader; +class Programs; class PaintParameters; struct ClipID; @@ -152,9 +151,9 @@ private: FrameHistory frameHistory; - std::unique_ptr shaders; + std::unique_ptr programs; #ifndef NDEBUG - std::unique_ptr overdrawShaders; + std::unique_ptr overdrawPrograms; #endif gl::VertexBuffer tileTriangleVertexBuffer; diff --git a/src/mbgl/renderer/painter_background.cpp b/src/mbgl/renderer/painter_background.cpp index a8ebf0de05..3e2597e47c 100644 --- a/src/mbgl/renderer/painter_background.cpp +++ b/src/mbgl/renderer/painter_background.cpp @@ -2,8 +2,8 @@ #include #include #include -#include -#include +#include +#include #include #include @@ -32,7 +32,7 @@ void Painter::renderBackground(PaintParameters& parameters, const BackgroundLaye depthModeForSublayer(0, gl::DepthMode::ReadOnly), gl::StencilMode::disabled(), colorModeForRenderPass(), - parameters.shaders.fillPattern, + parameters.programs.fillPattern, FillPatternUniforms::values( matrixForTile(tileID), properties.backgroundOpacity.value, @@ -52,8 +52,8 @@ void Painter::renderBackground(PaintParameters& parameters, const BackgroundLaye depthModeForSublayer(0, gl::DepthMode::ReadOnly), gl::StencilMode::disabled(), colorModeForRenderPass(), - parameters.shaders.fill, - FillColorUniforms::Values { + parameters.programs.fill, + FillProgram::UniformValues { uniforms::u_matrix::Value{ matrixForTile(tileID) }, uniforms::u_opacity::Value{ properties.backgroundOpacity.value }, uniforms::u_color::Value{ properties.backgroundColor.value }, diff --git a/src/mbgl/renderer/painter_circle.cpp b/src/mbgl/renderer/painter_circle.cpp index fedd1985ba..e4977b8abb 100644 --- a/src/mbgl/renderer/painter_circle.cpp +++ b/src/mbgl/renderer/painter_circle.cpp @@ -4,8 +4,8 @@ #include #include #include -#include -#include +#include +#include #include namespace mbgl { @@ -29,8 +29,8 @@ void Painter::renderCircle(PaintParameters& parameters, ? stencilModeForClipping(tile.clip) : gl::StencilMode::disabled(), colorModeForRenderPass(), - parameters.shaders.circle, - CircleUniforms::Values { + parameters.programs.circle, + CircleProgram::UniformValues { uniforms::u_matrix::Value{ tile.translatedMatrix(properties.circleTranslate.value, properties.circleTranslateAnchor.value, state) }, diff --git a/src/mbgl/renderer/painter_clipping.cpp b/src/mbgl/renderer/painter_clipping.cpp index 64558d667f..b64c5d5efc 100644 --- a/src/mbgl/renderer/painter_clipping.cpp +++ b/src/mbgl/renderer/painter_clipping.cpp @@ -1,6 +1,6 @@ #include -#include -#include +#include +#include #include namespace mbgl { @@ -17,8 +17,8 @@ void Painter::renderClippingMask(const UnwrappedTileID& tileID, const ClipID& cl gl::StencilMode::Replace }, gl::ColorMode::disabled(), - shaders->fill, - FillColorUniforms::Values { + programs->fill, + FillProgram::UniformValues { uniforms::u_matrix::Value{ matrixForTile(tileID) }, uniforms::u_opacity::Value{ 0.0f }, uniforms::u_color::Value{ Color {} }, diff --git a/src/mbgl/renderer/painter_debug.cpp b/src/mbgl/renderer/painter_debug.cpp index 08877949f6..a0fc98b8c1 100644 --- a/src/mbgl/renderer/painter_debug.cpp +++ b/src/mbgl/renderer/painter_debug.cpp @@ -4,8 +4,8 @@ #include #include #include -#include -#include +#include +#include #include #include #include @@ -23,8 +23,8 @@ void Painter::renderTileDebug(const RenderTile& renderTile) { gl::DepthMode::disabled(), stencilModeForClipping(renderTile.clip), gl::ColorMode::unblended(), - shaders->fill, - FillColorUniforms::Values { + programs->fill, + FillProgram::UniformValues { uniforms::u_matrix::Value{ renderTile.matrix }, uniforms::u_opacity::Value{ 1.0f }, uniforms::u_color::Value{ color }, diff --git a/src/mbgl/renderer/painter_fill.cpp b/src/mbgl/renderer/painter_fill.cpp index 5a9e7a9096..cdce181e1c 100644 --- a/src/mbgl/renderer/painter_fill.cpp +++ b/src/mbgl/renderer/painter_fill.cpp @@ -5,8 +5,8 @@ #include #include #include -#include -#include +#include +#include #include namespace mbgl { @@ -35,12 +35,12 @@ void Painter::renderFill(PaintParameters& parameters, spriteAtlas->bind(true, context, 0); - auto draw = [&] (uint8_t sublayer, auto& shader, const auto& subject) { + auto draw = [&] (uint8_t sublayer, auto& program, const auto& subject) { context.draw({ depthModeForSublayer(sublayer, gl::DepthMode::ReadWrite), stencilModeForClipping(tile.clip), colorModeForRenderPass(), - shader, + program, FillPatternUniforms::values( tile.translatedMatrix(properties.fillTranslate.value, properties.fillTranslateAnchor.value, @@ -58,7 +58,7 @@ void Painter::renderFill(PaintParameters& parameters, }; draw(0, - parameters.shaders.fillPattern, + parameters.programs.fillPattern, gl::Segmented( *bucket.vertexBuffer, *bucket.triangleIndexBuffer, @@ -69,20 +69,20 @@ void Painter::renderFill(PaintParameters& parameters, } draw(2, - parameters.shaders.fillOutlinePattern, + parameters.programs.fillOutlinePattern, gl::Segmented( *bucket.vertexBuffer, *bucket.lineIndexBuffer, bucket.lineSegments, 2.0f)); } else { - auto draw = [&] (uint8_t sublayer, auto& shader, Color outlineColor, const auto& subject) { + auto draw = [&] (uint8_t sublayer, auto& program, Color outlineColor, const auto& subject) { context.draw({ depthModeForSublayer(sublayer, gl::DepthMode::ReadWrite), stencilModeForClipping(tile.clip), colorModeForRenderPass(), - shader, - FillColorUniforms::Values { + program, + FillProgram::UniformValues { uniforms::u_matrix::Value{ tile.translatedMatrix(properties.fillTranslate.value, properties.fillTranslateAnchor.value, state) }, @@ -97,7 +97,7 @@ void Painter::renderFill(PaintParameters& parameters, if (properties.fillAntialias.value && !properties.fillOutlineColor.isUndefined() && pass == RenderPass::Translucent) { draw(2, - parameters.shaders.fillOutline, + parameters.programs.fillOutline, properties.fillOutlineColor.value, gl::Segmented( *bucket.vertexBuffer, @@ -110,7 +110,7 @@ void Painter::renderFill(PaintParameters& parameters, // or when it's translucent and we're drawing translucent fragments. if ((properties.fillColor.value.a >= 1.0f && properties.fillOpacity.value >= 1.0f) == (pass == RenderPass::Opaque)) { draw(1, - parameters.shaders.fill, + parameters.programs.fill, properties.fillOutlineColor.value, gl::Segmented( *bucket.vertexBuffer, @@ -120,7 +120,7 @@ void Painter::renderFill(PaintParameters& parameters, if (properties.fillAntialias.value && properties.fillOutlineColor.isUndefined() && pass == RenderPass::Translucent) { draw(2, - parameters.shaders.fillOutline, + parameters.programs.fillOutline, properties.fillColor.value, gl::Segmented( *bucket.vertexBuffer, diff --git a/src/mbgl/renderer/painter_line.cpp b/src/mbgl/renderer/painter_line.cpp index 377c956e7c..7f9556fd3f 100644 --- a/src/mbgl/renderer/painter_line.cpp +++ b/src/mbgl/renderer/painter_line.cpp @@ -4,8 +4,8 @@ #include #include #include -#include -#include +#include +#include #include #include @@ -23,12 +23,12 @@ void Painter::renderLine(PaintParameters& parameters, const auto& properties = layer.impl->paint; - auto draw = [&] (auto& shader, auto&& uniformValues) { + auto draw = [&] (auto& program, auto&& uniformValues) { context.draw({ depthModeForSublayer(0, gl::DepthMode::ReadOnly), stencilModeForClipping(tile.clip), colorModeForRenderPass(), - shader, + program, std::move(uniformValues), gl::Segmented( *bucket.vertexBuffer, @@ -46,8 +46,8 @@ void Painter::renderLine(PaintParameters& parameters, lineAtlas->bind(context, 0); - draw(parameters.shaders.lineSDF, - LineSDFUniforms::values( + draw(parameters.programs.lineSDF, + LineSDFProgram::uniformValues( properties, frame.pixelRatio, tile, @@ -68,8 +68,8 @@ void Painter::renderLine(PaintParameters& parameters, spriteAtlas->bind(true, context, 0); - draw(parameters.shaders.linePattern, - LinePatternUniforms::values( + draw(parameters.programs.linePattern, + LinePatternProgram::uniformValues( properties, frame.pixelRatio, tile, @@ -78,8 +78,8 @@ void Painter::renderLine(PaintParameters& parameters, *posB)); } else { - draw(parameters.shaders.line, - LineColorUniforms::values( + draw(parameters.programs.line, + LineProgram::uniformValues( properties, frame.pixelRatio, tile, diff --git a/src/mbgl/renderer/painter_raster.cpp b/src/mbgl/renderer/painter_raster.cpp index 6acd29eb37..c619cad2aa 100644 --- a/src/mbgl/renderer/painter_raster.cpp +++ b/src/mbgl/renderer/painter_raster.cpp @@ -4,8 +4,8 @@ #include #include #include -#include -#include +#include +#include namespace mbgl { @@ -58,8 +58,8 @@ void Painter::renderRaster(PaintParameters& parameters, depthModeForSublayer(0, gl::DepthMode::ReadOnly), gl::StencilMode::disabled(), colorModeForRenderPass(), - parameters.shaders.raster, - RasterUniforms::Values { + parameters.programs.raster, + RasterProgram::UniformValues { uniforms::u_matrix::Value{ tile.matrix }, uniforms::u_image0::Value{ 0 }, uniforms::u_image1::Value{ 1 }, diff --git a/src/mbgl/renderer/painter_symbol.cpp b/src/mbgl/renderer/painter_symbol.cpp index cf4bb9ee86..2f94544486 100644 --- a/src/mbgl/renderer/painter_symbol.cpp +++ b/src/mbgl/renderer/painter_symbol.cpp @@ -6,9 +6,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include #include #include @@ -30,7 +30,7 @@ void Painter::renderSymbol(PaintParameters& parameters, frameHistory.bind(context, 1); - auto draw = [&] (auto& shader, + auto draw = [&] (auto& program, auto&& uniformValues, const auto& buffers, const SymbolPropertyValues& values_) @@ -54,7 +54,7 @@ void Painter::renderSymbol(PaintParameters& parameters, ? gl::StencilMode::disabled() : stencilModeForClipping(tile.clip), colorModeForRenderPass(), - shader, + program, std::move(uniformValues), gl::Segmented( *buffers.vertexBuffer, @@ -76,21 +76,21 @@ void Painter::renderSymbol(PaintParameters& parameters, if (bucket.sdfIcons) { if (values.hasHalo()) { - draw(parameters.shaders.symbolIconSDF, - SymbolSDFUniforms::haloValues(values, texsize, pixelsToGLUnits, tile, state, frame.pixelRatio), + draw(parameters.programs.symbolIconSDF, + SymbolSDFProgram::haloUniformValues(values, texsize, pixelsToGLUnits, tile, state, frame.pixelRatio), bucket.icon, values); } if (values.hasForeground()) { - draw(parameters.shaders.symbolIconSDF, - SymbolSDFUniforms::foregroundValues(values, texsize, pixelsToGLUnits, tile, state, frame.pixelRatio), + draw(parameters.programs.symbolIconSDF, + SymbolSDFProgram::foregroundUniformValues(values, texsize, pixelsToGLUnits, tile, state, frame.pixelRatio), bucket.icon, values); } } else { - draw(parameters.shaders.symbolIcon, - SymbolIconUniforms::values(values, texsize, pixelsToGLUnits, tile, state), + draw(parameters.programs.symbolIcon, + SymbolIconProgram::uniformValues(values, texsize, pixelsToGLUnits, tile, state), bucket.icon, values); } @@ -104,15 +104,15 @@ void Painter::renderSymbol(PaintParameters& parameters, const Size texsize = glyphAtlas->getSize(); if (values.hasHalo()) { - draw(parameters.shaders.symbolGlyph, - SymbolSDFUniforms::haloValues(values, texsize, pixelsToGLUnits, tile, state, frame.pixelRatio), + draw(parameters.programs.symbolGlyph, + SymbolSDFProgram::haloUniformValues(values, texsize, pixelsToGLUnits, tile, state, frame.pixelRatio), bucket.text, values); } if (values.hasForeground()) { - draw(parameters.shaders.symbolGlyph, - SymbolSDFUniforms::foregroundValues(values, texsize, pixelsToGLUnits, tile, state, frame.pixelRatio), + draw(parameters.programs.symbolGlyph, + SymbolSDFProgram::foregroundUniformValues(values, texsize, pixelsToGLUnits, tile, state, frame.pixelRatio), bucket.text, values); } @@ -123,8 +123,8 @@ void Painter::renderSymbol(PaintParameters& parameters, gl::DepthMode::disabled(), gl::StencilMode::disabled(), colorModeForRenderPass(), - shaders->collisionBox, - CollisionBoxUniforms::Values { + programs->collisionBox, + CollisionBoxProgram::UniformValues { uniforms::u_matrix::Value{ tile.matrix }, uniforms::u_scale::Value{ std::pow(2.0f, float(state.getZoom() - tile.tile.id.overscaledZ)) }, uniforms::u_zoom::Value{ float(state.getZoom() * 10) }, diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp index bfe728c0b0..0355911296 100644 --- a/src/mbgl/renderer/raster_bucket.cpp +++ b/src/mbgl/renderer/raster_bucket.cpp @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp index 993d3b85d8..d33341008e 100644 --- a/src/mbgl/renderer/symbol_bucket.hpp +++ b/src/mbgl/renderer/symbol_bucket.hpp @@ -5,8 +5,8 @@ #include #include #include -#include -#include +#include +#include #include #include diff --git a/src/mbgl/shader/attributes.hpp b/src/mbgl/shader/attributes.hpp deleted file mode 100644 index 38bbe89377..0000000000 --- a/src/mbgl/shader/attributes.hpp +++ /dev/null @@ -1,23 +0,0 @@ -#pragma once - -#include - -#include - -namespace mbgl { -namespace attributes { - -// Attributes common to several shaders. - -MBGL_DEFINE_ATTRIBUTE(int16_t, 2, a_pos); -MBGL_DEFINE_ATTRIBUTE(int16_t, 2, a_offset); -MBGL_DEFINE_ATTRIBUTE(int16_t, 2, a_extrude); -MBGL_DEFINE_ATTRIBUTE(uint16_t, 2, a_texture_pos); - -template -struct a_data : gl::Attribute, uint8_t, N> { - static constexpr auto name = "a_data"; -}; - -} // namespace attributes -} // namespace mbgl diff --git a/src/mbgl/shader/circle_attributes.hpp b/src/mbgl/shader/circle_attributes.hpp deleted file mode 100644 index 92f8ff1e5c..0000000000 --- a/src/mbgl/shader/circle_attributes.hpp +++ /dev/null @@ -1,30 +0,0 @@ -#pragma once - -#include -#include - -namespace mbgl { - -struct CircleAttributes : gl::Attributes< - attributes::a_pos> -{ - /* - * @param {number} x vertex position - * @param {number} y vertex position - * @param {number} ex extrude normal - * @param {number} ey extrude normal - */ - static Vertex vertex(Point p, float ex, float ey) { - return Vertex { - { - static_cast((p.x * 2) + ((ex + 1) / 2)), - static_cast((p.y * 2) + ((ey + 1) / 2)) - } - }; - } -}; - -using CircleVertex = CircleAttributes::Vertex; -static_assert(sizeof(CircleVertex) == 4, "expected CircleVertex size"); - -} // namespace mbgl diff --git a/src/mbgl/shader/circle_shader.cpp b/src/mbgl/shader/circle_shader.cpp deleted file mode 100644 index f873d834f0..0000000000 --- a/src/mbgl/shader/circle_shader.cpp +++ /dev/null @@ -1,16 +0,0 @@ -#include -#include -#include - -namespace mbgl { - -CircleShader::CircleShader(gl::Context& context, Defines defines) - : Shader(shaders::circle::name, - shaders::circle::vertex, - shaders::circle::fragment, - context, defines), - attributesState(CircleAttributes::state(*this)), - uniformsState(CircleUniforms::state(*this)) { -} - -} // namespace mbgl diff --git a/src/mbgl/shader/circle_shader.hpp b/src/mbgl/shader/circle_shader.hpp deleted file mode 100644 index 35d052bf9b..0000000000 --- a/src/mbgl/shader/circle_shader.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { - -class CircleShader : public gl::Shader { -public: - CircleShader(gl::Context&, Defines defines = None); - - using AttributesType = CircleAttributes; - using UniformsType = CircleUniforms; - - typename CircleAttributes::State attributesState; - typename CircleUniforms::State uniformsState; -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/circle_uniforms.hpp b/src/mbgl/shader/circle_uniforms.hpp deleted file mode 100644 index c77c0daaba..0000000000 --- a/src/mbgl/shader/circle_uniforms.hpp +++ /dev/null @@ -1,23 +0,0 @@ -#pragma once - -#include - -namespace mbgl { - -namespace uniforms { -MBGL_DEFINE_UNIFORM_SCALAR(float, u_radius); -MBGL_DEFINE_UNIFORM_SCALAR(bool, u_scale_with_map); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_devicepixelratio); -} // namespace uniforms - -struct CircleUniforms : gl::Uniforms< - uniforms::u_matrix, - uniforms::u_opacity, - uniforms::u_color, - uniforms::u_radius, - uniforms::u_blur, - uniforms::u_scale_with_map, - uniforms::u_extrude_scale, - uniforms::u_devicepixelratio> {}; - -} // namespace mbgl diff --git a/src/mbgl/shader/collision_box_attributes.hpp b/src/mbgl/shader/collision_box_attributes.hpp deleted file mode 100644 index c3131d6c27..0000000000 --- a/src/mbgl/shader/collision_box_attributes.hpp +++ /dev/null @@ -1,36 +0,0 @@ -#pragma once - -#include -#include - -#include - -namespace mbgl { - -struct CollisionBoxAttributes : gl::Attributes< - attributes::a_pos, - attributes::a_extrude, - attributes::a_data<2>> -{ - static Vertex vertex(Point a, Point o, float maxzoom, float placementZoom) { - return Vertex { - { - static_cast(a.x), - static_cast(a.y) - }, - { - static_cast(::round(o.x)), - static_cast(::round(o.y)) - }, - { - static_cast(maxzoom * 10), - static_cast(placementZoom * 10) - } - }; - } -}; - -using CollisionBoxVertex = CollisionBoxAttributes::Vertex; -static_assert(sizeof(CollisionBoxVertex) == 10, "expected CollisionBoxVertex size"); - -} // namespace mbgl diff --git a/src/mbgl/shader/collision_box_shader.cpp b/src/mbgl/shader/collision_box_shader.cpp deleted file mode 100644 index 61f6113234..0000000000 --- a/src/mbgl/shader/collision_box_shader.cpp +++ /dev/null @@ -1,17 +0,0 @@ -#include -#include -#include - -namespace mbgl { - -CollisionBoxShader::CollisionBoxShader(gl::Context& context) - : Shader(shaders::collision_box::name, - shaders::collision_box::vertex, - shaders::collision_box::fragment, - context), - attributesState(CollisionBoxAttributes::state(*this)), - uniformsState(CollisionBoxUniforms::state(*this)) -{ -} - -} // namespace mbgl diff --git a/src/mbgl/shader/collision_box_shader.hpp b/src/mbgl/shader/collision_box_shader.hpp deleted file mode 100644 index 8995507eee..0000000000 --- a/src/mbgl/shader/collision_box_shader.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { - -class CollisionBoxShader : public gl::Shader { -public: - CollisionBoxShader(gl::Context&); - - using AttributesType = CollisionBoxAttributes; - using UniformsType = CollisionBoxUniforms; - - typename CollisionBoxAttributes::State attributesState; - typename CollisionBoxUniforms::State uniformsState; -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/collision_box_uniforms.hpp b/src/mbgl/shader/collision_box_uniforms.hpp deleted file mode 100644 index f195cc9a6a..0000000000 --- a/src/mbgl/shader/collision_box_uniforms.hpp +++ /dev/null @@ -1,18 +0,0 @@ -#pragma once - -#include - -namespace mbgl { - -namespace uniforms { -MBGL_DEFINE_UNIFORM_SCALAR(float, u_scale); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_maxzoom); -} // namespace uniforms - -struct CollisionBoxUniforms : gl::Uniforms< - uniforms::u_matrix, - uniforms::u_scale, - uniforms::u_zoom, - uniforms::u_maxzoom> {}; - -} // namespace mbgl diff --git a/src/mbgl/shader/fill_attributes.hpp b/src/mbgl/shader/fill_attributes.hpp deleted file mode 100644 index 83e4df3543..0000000000 --- a/src/mbgl/shader/fill_attributes.hpp +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -#include -#include - -namespace mbgl { - -struct FillAttributes : gl::Attributes< - attributes::a_pos> { - - static Vertex vertex(Point p) { - return Vertex { - { - p.x, - p.y - } - }; - } -}; - -using FillVertex = FillAttributes::Vertex; -static_assert(sizeof(FillVertex) == 4, "expected FillVertex size"); - -} // namespace mbgl diff --git a/src/mbgl/shader/fill_outline_pattern_shader.cpp b/src/mbgl/shader/fill_outline_pattern_shader.cpp deleted file mode 100644 index 723366f6d0..0000000000 --- a/src/mbgl/shader/fill_outline_pattern_shader.cpp +++ /dev/null @@ -1,16 +0,0 @@ -#include -#include -#include - -namespace mbgl { - -FillOutlinePatternShader::FillOutlinePatternShader(gl::Context& context, Defines defines) - : Shader(shaders::fill_outline_pattern::name, - shaders::fill_outline_pattern::vertex, - shaders::fill_outline_pattern::fragment, - context, defines), - attributesState(FillAttributes::state(*this)), - uniformsState(FillPatternUniforms::state(*this)) { -} - -} // namespace mbgl diff --git a/src/mbgl/shader/fill_outline_pattern_shader.hpp b/src/mbgl/shader/fill_outline_pattern_shader.hpp deleted file mode 100644 index a33aa532fe..0000000000 --- a/src/mbgl/shader/fill_outline_pattern_shader.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { - -class FillOutlinePatternShader : public gl::Shader { -public: - FillOutlinePatternShader(gl::Context&, Defines defines = None); - - using AttributesType = FillAttributes; - using UniformsType = FillPatternUniforms; - - typename FillAttributes::State attributesState; - typename FillPatternUniforms::State uniformsState; -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/fill_outline_shader.cpp b/src/mbgl/shader/fill_outline_shader.cpp deleted file mode 100644 index 909b652e7f..0000000000 --- a/src/mbgl/shader/fill_outline_shader.cpp +++ /dev/null @@ -1,16 +0,0 @@ -#include -#include -#include - -namespace mbgl { - -FillOutlineShader::FillOutlineShader(gl::Context& context, Defines defines) - : Shader(shaders::fill_outline::name, - shaders::fill_outline::vertex, - shaders::fill_outline::fragment, - context, defines), - attributesState(FillAttributes::state(*this)), - uniformsState(FillColorUniforms::state(*this)) { -} - -} // namespace mbgl diff --git a/src/mbgl/shader/fill_outline_shader.hpp b/src/mbgl/shader/fill_outline_shader.hpp deleted file mode 100644 index e68861641f..0000000000 --- a/src/mbgl/shader/fill_outline_shader.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { - -class FillOutlineShader : public gl::Shader { -public: - FillOutlineShader(gl::Context&, Defines defines = None); - - using AttributesType = FillAttributes; - using UniformsType = FillColorUniforms; - - typename FillAttributes::State attributesState; - typename FillColorUniforms::State uniformsState; -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/fill_pattern_shader.cpp b/src/mbgl/shader/fill_pattern_shader.cpp deleted file mode 100644 index 60f9d74c1a..0000000000 --- a/src/mbgl/shader/fill_pattern_shader.cpp +++ /dev/null @@ -1,16 +0,0 @@ -#include -#include -#include - -namespace mbgl { - -FillPatternShader::FillPatternShader(gl::Context& context, Defines defines) - : Shader(shaders::fill_pattern::name, - shaders::fill_pattern::vertex, - shaders::fill_pattern::fragment, - context, defines), - attributesState(FillAttributes::state(*this)), - uniformsState(FillPatternUniforms::state(*this)) { -} - -} // namespace mbgl diff --git a/src/mbgl/shader/fill_pattern_shader.hpp b/src/mbgl/shader/fill_pattern_shader.hpp deleted file mode 100644 index 1ea378b822..0000000000 --- a/src/mbgl/shader/fill_pattern_shader.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { - -class FillPatternShader : public gl::Shader { -public: - FillPatternShader(gl::Context&, Defines defines = None); - - using AttributesType = FillAttributes; - using UniformsType = FillPatternUniforms; - - typename FillAttributes::State attributesState; - typename FillPatternUniforms::State uniformsState; -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/fill_shader.cpp b/src/mbgl/shader/fill_shader.cpp deleted file mode 100644 index 457ecbb0ba..0000000000 --- a/src/mbgl/shader/fill_shader.cpp +++ /dev/null @@ -1,16 +0,0 @@ -#include -#include -#include - -namespace mbgl { - -FillShader::FillShader(gl::Context& context, Defines defines) - : Shader(shaders::fill::name, - shaders::fill::vertex, - shaders::fill::fragment, - context, defines), - attributesState(FillAttributes::state(*this)), - uniformsState(FillColorUniforms::state(*this)) { -} - -} // namespace mbgl diff --git a/src/mbgl/shader/fill_shader.hpp b/src/mbgl/shader/fill_shader.hpp deleted file mode 100644 index 4b8b4ed4f9..0000000000 --- a/src/mbgl/shader/fill_shader.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { - -class FillShader : public gl::Shader { -public: - FillShader(gl::Context&, Defines defines = None); - - using AttributesType = FillAttributes; - using UniformsType = FillColorUniforms; - - typename FillAttributes::State attributesState; - typename FillColorUniforms::State uniformsState; -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/fill_uniforms.cpp b/src/mbgl/shader/fill_uniforms.cpp deleted file mode 100644 index acd207c5d4..0000000000 --- a/src/mbgl/shader/fill_uniforms.cpp +++ /dev/null @@ -1,45 +0,0 @@ -#include -#include -#include -#include -#include - -namespace mbgl { - -using namespace style; - -FillPatternUniforms::Values -FillPatternUniforms::values(mat4 matrix, - float opacity, - Size framebufferSize, - const SpriteAtlasPosition& a, - const SpriteAtlasPosition& b, - const Faded& fading, - const UnwrappedTileID& tileID, - const TransformState& state) -{ - int32_t tileSizeAtNearestZoom = util::tileSize * state.zoomScale(state.getIntegerZoom() - tileID.canonical.z); - int32_t pixelX = tileSizeAtNearestZoom * (tileID.canonical.x + tileID.wrap * state.zoomScale(tileID.canonical.z)); - int32_t pixelY = tileSizeAtNearestZoom * tileID.canonical.y; - - return FillPatternUniforms::Values { - uniforms::u_matrix::Value{ matrix }, - uniforms::u_opacity::Value{ opacity }, - uniforms::u_world::Value{ framebufferSize }, - uniforms::u_pattern_tl_a::Value{ a.tl }, - uniforms::u_pattern_br_a::Value{ a.br }, - uniforms::u_pattern_tl_b::Value{ b.tl }, - uniforms::u_pattern_br_b::Value{ b.br }, - uniforms::u_pattern_size_a::Value{ a.size }, - uniforms::u_pattern_size_b::Value{ b.size }, - uniforms::u_scale_a::Value{ fading.fromScale }, - uniforms::u_scale_b::Value{ fading.toScale }, - uniforms::u_mix::Value{ fading.t }, - uniforms::u_image::Value{ 0 }, - uniforms::u_pixel_coord_upper::Value{ std::array {{ float(pixelX >> 16), float(pixelY >> 16) }} }, - uniforms::u_pixel_coord_lower::Value{ std::array {{ float(pixelX & 0xFFFF), float(pixelY & 0xFFFF) }} }, - uniforms::u_tile_units_to_pixels::Value{ 1.0f / tileID.pixelsToTileUnits(1.0f, state.getIntegerZoom()) }, - }; -} - -} // namespace mbgl diff --git a/src/mbgl/shader/fill_uniforms.hpp b/src/mbgl/shader/fill_uniforms.hpp deleted file mode 100644 index a596da0ea9..0000000000 --- a/src/mbgl/shader/fill_uniforms.hpp +++ /dev/null @@ -1,63 +0,0 @@ -#pragma once - -#include -#include -#include - -#include - -namespace mbgl { - -namespace uniforms { -MBGL_DEFINE_UNIFORM_SCALAR(Size, u_world); -MBGL_DEFINE_UNIFORM_SCALAR(Color, u_outline_color); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_scale_a); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_scale_b); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_tile_units_to_pixels); -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pixel_coord_upper); -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pixel_coord_lower); -} // namespace uniforms - -struct FillColorUniforms : gl::Uniforms< - uniforms::u_matrix, - uniforms::u_opacity, - uniforms::u_color, - uniforms::u_outline_color, - uniforms::u_world> {}; - -class SpriteAtlasPosition; -class UnwrappedTileID; -class TransformState; - -namespace style { -template class Faded; -} // namespace style - -struct FillPatternUniforms : gl::Uniforms< - uniforms::u_matrix, - uniforms::u_opacity, - uniforms::u_world, - uniforms::u_pattern_tl_a, - uniforms::u_pattern_br_a, - uniforms::u_pattern_tl_b, - uniforms::u_pattern_br_b, - uniforms::u_pattern_size_a, - uniforms::u_pattern_size_b, - uniforms::u_scale_a, - uniforms::u_scale_b, - uniforms::u_mix, - uniforms::u_image, - uniforms::u_pixel_coord_upper, - uniforms::u_pixel_coord_lower, - uniforms::u_tile_units_to_pixels> { - static Values values(mat4 matrix, - float opacity, - Size framebufferSize, - const SpriteAtlasPosition&, - const SpriteAtlasPosition&, - const style::Faded&, - const UnwrappedTileID&, - const TransformState&); -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/line_attributes.hpp b/src/mbgl/shader/line_attributes.hpp deleted file mode 100644 index 1f7dc85201..0000000000 --- a/src/mbgl/shader/line_attributes.hpp +++ /dev/null @@ -1,60 +0,0 @@ -#pragma once - -#include -#include - -#include - -namespace mbgl { - -struct LineAttributes : gl::Attributes< - attributes::a_pos, - attributes::a_data<4>> { - - /* - * @param p vertex position - * @param e extrude normal - * @param t texture normal - * @param dir direction of the line cap (-1/0/1) - */ - static Vertex vertex(Point p, Point e, Point t, int8_t dir, int32_t linesofar = 0) { - return Vertex { - { - static_cast((p.x * 2) | t.x), - static_cast((p.y * 2) | t.y) - }, - { - // add 128 to store an byte in an unsigned byte - static_cast(::round(extrudeScale * e.x) + 128), - static_cast(::round(extrudeScale * e.y) + 128), - - // Encode the -1/0/1 direction value into the first two bits of .z of a_data. - // Combine it with the lower 6 bits of `linesofar` (shifted by 2 bites to make - // room for the direction value). The upper 8 bits of `linesofar` are placed in - // the `w` component. `linesofar` is scaled down by `LINE_DISTANCE_SCALE` so that - // we can store longer distances while sacrificing precision. - - // Encode the -1/0/1 direction value into .zw coordinates of a_data, which is normally covered - // by linesofar, so we need to merge them. - // The z component's first bit, as well as the sign bit is reserved for the direction, - // so we need to shift the linesofar. - static_cast(((dir == 0 ? 0 : (dir < 0 ? -1 : 1 )) + 1) | ((linesofar & 0x3F) << 2)), - static_cast(linesofar >> 6) - } - }; - } - - /* - * Scale the extrusion vector so that the normal length is this value. - * Contains the "texture" normals (-1..1). This is distinct from the extrude - * normals for line joins, because the x-value remains 0 for the texture - * normal array, while the extrude normal actually moves the vertex to create - * the acute/bevelled line join. - */ - static const int8_t extrudeScale = 63; -}; - -using LineVertex = LineAttributes::Vertex; -static_assert(sizeof(LineVertex) == 8, "expected LineVertex size"); - -} // namespace mbgl diff --git a/src/mbgl/shader/line_pattern_shader.cpp b/src/mbgl/shader/line_pattern_shader.cpp deleted file mode 100644 index 6085e033c6..0000000000 --- a/src/mbgl/shader/line_pattern_shader.cpp +++ /dev/null @@ -1,16 +0,0 @@ -#include -#include -#include - -namespace mbgl { - -LinePatternShader::LinePatternShader(gl::Context& context, Defines defines) - : Shader(shaders::line_pattern::name, - shaders::line_pattern::vertex, - shaders::line_pattern::fragment, - context, defines), - attributesState(LineAttributes::state(*this)), - uniformsState(LinePatternUniforms::state(*this)) { -} - -} // namespace mbgl diff --git a/src/mbgl/shader/line_pattern_shader.hpp b/src/mbgl/shader/line_pattern_shader.hpp deleted file mode 100644 index d1013ce4f0..0000000000 --- a/src/mbgl/shader/line_pattern_shader.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { - -class LinePatternShader : public gl::Shader { -public: - LinePatternShader(gl::Context&, Defines defines = None); - - using AttributesType = LineAttributes; - using UniformsType = LinePatternUniforms; - - typename LineAttributes::State attributesState; - typename LinePatternUniforms::State uniformsState; -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/line_sdf_shader.cpp b/src/mbgl/shader/line_sdf_shader.cpp deleted file mode 100644 index ee36c3309f..0000000000 --- a/src/mbgl/shader/line_sdf_shader.cpp +++ /dev/null @@ -1,16 +0,0 @@ -#include -#include -#include - -namespace mbgl { - -LineSDFShader::LineSDFShader(gl::Context& context, Defines defines) - : Shader(shaders::line_sdf::name, - shaders::line_sdf::vertex, - shaders::line_sdf::fragment, - context, defines), - attributesState(LineAttributes::state(*this)), - uniformsState(LineSDFUniforms::state(*this)) { -} - -} // namespace mbgl diff --git a/src/mbgl/shader/line_sdf_shader.hpp b/src/mbgl/shader/line_sdf_shader.hpp deleted file mode 100644 index 4f793f5609..0000000000 --- a/src/mbgl/shader/line_sdf_shader.hpp +++ /dev/null @@ -1,21 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { - -class LineSDFShader : public gl::Shader { -public: - LineSDFShader(gl::Context&, Defines defines = None); - - using AttributesType = LineAttributes; - using UniformsType = LineSDFUniforms; - - typename LineAttributes::State attributesState; - typename LineSDFUniforms::State uniformsState; -}; - - -} // namespace mbgl diff --git a/src/mbgl/shader/line_shader.cpp b/src/mbgl/shader/line_shader.cpp deleted file mode 100644 index 4bb44de16d..0000000000 --- a/src/mbgl/shader/line_shader.cpp +++ /dev/null @@ -1,16 +0,0 @@ -#include -#include -#include - -namespace mbgl { - -LineShader::LineShader(gl::Context& context, Defines defines) - : Shader(shaders::line::name, - shaders::line::vertex, - shaders::line::fragment, - context, defines), - attributesState(LineAttributes::state(*this)), - uniformsState(LineColorUniforms::state(*this)) { -} - -} // namespace mbgl diff --git a/src/mbgl/shader/line_shader.hpp b/src/mbgl/shader/line_shader.hpp deleted file mode 100644 index 91ae41e95a..0000000000 --- a/src/mbgl/shader/line_shader.hpp +++ /dev/null @@ -1,21 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { - -class LineShader : public gl::Shader { -public: - LineShader(gl::Context&, Defines defines = None); - - using AttributesType = LineAttributes; - using UniformsType = LineColorUniforms; - - typename LineAttributes::State attributesState; - typename LineColorUniforms::State uniformsState; -}; - - -} // namespace mbgl diff --git a/src/mbgl/shader/line_uniforms.cpp b/src/mbgl/shader/line_uniforms.cpp deleted file mode 100644 index 0e9e5e27f0..0000000000 --- a/src/mbgl/shader/line_uniforms.cpp +++ /dev/null @@ -1,133 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include - -namespace mbgl { - -template -Values makeValues(const style::LinePaintProperties& properties, - float pixelRatio, - const RenderTile& tile, - const TransformState& state, - Args&&... args) { - // the distance over which the line edge fades out. - // Retina devices need a smaller distance to avoid aliasing. - float antialiasing = 1.0 / pixelRatio; - - mat2 antialiasingMatrix; - matrix::identity(antialiasingMatrix); - matrix::scale(antialiasingMatrix, antialiasingMatrix, 1.0, std::cos(state.getPitch())); - matrix::rotate(antialiasingMatrix, antialiasingMatrix, state.getAngle()); - - // calculate how much longer the real world distance is at the top of the screen - // than at the middle of the screen. - float topedgelength = std::sqrt(std::pow(state.getSize().height, 2.0f) / 4.0f * (1.0f + std::pow(state.getAltitude(), 2.0f))); - float x = state.getSize().height / 2.0f * std::tan(state.getPitch()); - - return Values { - uniforms::u_matrix::Value{ tile.translatedMatrix(properties.lineTranslate.value, - properties.lineTranslateAnchor.value, - state) }, - uniforms::u_opacity::Value{ properties.lineOpacity.value }, - uniforms::u_linewidth::Value{ properties.lineWidth.value / 2 }, - uniforms::u_gapwidth::Value{ properties.lineGapWidth.value / 2 }, - uniforms::u_blur::Value{ properties.lineBlur.value + antialiasing }, - uniforms::u_offset::Value{ -properties.lineOffset.value }, - uniforms::u_antialiasing::Value{ antialiasing / 2 }, - uniforms::u_antialiasingmatrix::Value{ antialiasingMatrix }, - uniforms::u_ratio::Value{ 1.0f / tile.id.pixelsToTileUnits(1.0, state.getZoom()) }, - uniforms::u_extra::Value{ (topedgelength + x) / topedgelength - 1.0f }, - std::forward(args)... - }; -} - -LineColorUniforms::Values -LineColorUniforms::values(const style::LinePaintProperties& properties, - float pixelRatio, - const RenderTile& tile, - const TransformState& state) { - return makeValues( - properties, - pixelRatio, - tile, - state, - uniforms::u_color::Value{ properties.lineColor.value } - ); -} - -LineSDFUniforms::Values -LineSDFUniforms::values(const style::LinePaintProperties& properties, - float pixelRatio, - const RenderTile& tile, - const TransformState& state, - const LinePatternPos& posA, - const LinePatternPos& posB, - float dashLineWidth, - float atlasWidth) { - const float widthA = posA.width * properties.lineDasharray.value.fromScale * dashLineWidth; - const float widthB = posB.width * properties.lineDasharray.value.toScale * dashLineWidth; - - std::array scaleA {{ - 1.0f / tile.id.pixelsToTileUnits(widthA, state.getIntegerZoom()), - -posA.height / 2.0f - }}; - - std::array scaleB {{ - 1.0f / tile.id.pixelsToTileUnits(widthB, state.getIntegerZoom()), - -posB.height / 2.0f - }}; - - return makeValues( - properties, - pixelRatio, - tile, - state, - uniforms::u_color::Value{ properties.lineColor.value }, - uniforms::u_patternscale_a::Value{ scaleA }, - uniforms::u_patternscale_b::Value{ scaleB }, - uniforms::u_tex_y_a::Value{ posA.y }, - uniforms::u_tex_y_b::Value{ posB.y }, - uniforms::u_mix::Value{ properties.lineDasharray.value.t }, - uniforms::u_sdfgamma::Value{ atlasWidth / (std::min(widthA, widthB) * 256.0f * pixelRatio) / 2.0f }, - uniforms::u_image::Value{ 0 } - ); -} - -LinePatternUniforms::Values -LinePatternUniforms::values(const style::LinePaintProperties& properties, - float pixelRatio, - const RenderTile& tile, - const TransformState& state, - const SpriteAtlasPosition& posA, - const SpriteAtlasPosition& posB) { - std::array sizeA {{ - tile.id.pixelsToTileUnits(posA.size[0] * properties.linePattern.value.fromScale, state.getIntegerZoom()), - posA.size[1] - }}; - - std::array sizeB {{ - tile.id.pixelsToTileUnits(posB.size[0] * properties.linePattern.value.toScale, state.getIntegerZoom()), - posB.size[1] - }}; - - return makeValues( - properties, - pixelRatio, - tile, - state, - uniforms::u_pattern_tl_a::Value{ posA.tl }, - uniforms::u_pattern_br_a::Value{ posA.br }, - uniforms::u_pattern_tl_b::Value{ posB.tl }, - uniforms::u_pattern_br_b::Value{ posB.br }, - uniforms::u_pattern_size_a::Value{ sizeA }, - uniforms::u_pattern_size_b::Value{ sizeB }, - uniforms::u_fade::Value{ properties.linePattern.value.t }, - uniforms::u_image::Value{ 0 } - ); -} - -} // namespace mbgl diff --git a/src/mbgl/shader/line_uniforms.hpp b/src/mbgl/shader/line_uniforms.hpp deleted file mode 100644 index 8a9c5310b5..0000000000 --- a/src/mbgl/shader/line_uniforms.hpp +++ /dev/null @@ -1,109 +0,0 @@ -#pragma once - -#include - -namespace mbgl { - -namespace style { -class LinePaintProperties; -} // namespace style - -class RenderTile; -class TransformState; -class LinePatternPos; -class SpriteAtlasPosition; - -namespace uniforms { -MBGL_DEFINE_UNIFORM_SCALAR(float, u_ratio); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_linewidth); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_gapwidth); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_antialiasing); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_extra); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_offset); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_tex_y_a); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_tex_y_b); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_sdfgamma); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_fade); -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_patternscale_a); -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_patternscale_b); -MBGL_DEFINE_UNIFORM_MATRIX(double, 2, u_antialiasingmatrix); -} // namespace uniforms - -struct LineColorUniforms : gl::Uniforms< - uniforms::u_matrix, - uniforms::u_opacity, - uniforms::u_linewidth, - uniforms::u_gapwidth, - uniforms::u_blur, - uniforms::u_offset, - uniforms::u_antialiasing, - uniforms::u_antialiasingmatrix, - uniforms::u_ratio, - uniforms::u_extra, - uniforms::u_color> -{ - static Values values(const style::LinePaintProperties&, - float pixelRatio, - const RenderTile&, - const TransformState&); -}; - -struct LineSDFUniforms : gl::Uniforms< - uniforms::u_matrix, - uniforms::u_opacity, - uniforms::u_linewidth, - uniforms::u_gapwidth, - uniforms::u_blur, - uniforms::u_offset, - uniforms::u_antialiasing, - uniforms::u_antialiasingmatrix, - uniforms::u_ratio, - uniforms::u_extra, - uniforms::u_color, - uniforms::u_patternscale_a, - uniforms::u_patternscale_b, - uniforms::u_tex_y_a, - uniforms::u_tex_y_b, - uniforms::u_mix, - uniforms::u_sdfgamma, - uniforms::u_image> -{ - static Values values(const style::LinePaintProperties&, - float pixelRatio, - const RenderTile&, - const TransformState&, - const LinePatternPos& posA, - const LinePatternPos& posB, - float dashLineWidth, - float atlasWidth); -}; - -struct LinePatternUniforms : gl::Uniforms< - uniforms::u_matrix, - uniforms::u_opacity, - uniforms::u_linewidth, - uniforms::u_gapwidth, - uniforms::u_blur, - uniforms::u_offset, - uniforms::u_antialiasing, - uniforms::u_antialiasingmatrix, - uniforms::u_ratio, - uniforms::u_extra, - uniforms::u_pattern_tl_a, - uniforms::u_pattern_br_a, - uniforms::u_pattern_tl_b, - uniforms::u_pattern_br_b, - uniforms::u_pattern_size_a, - uniforms::u_pattern_size_b, - uniforms::u_fade, - uniforms::u_image> -{ - static Values values(const style::LinePaintProperties&, - float pixelRatio, - const RenderTile&, - const TransformState&, - const SpriteAtlasPosition& posA, - const SpriteAtlasPosition& posB); -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/raster_attributes.hpp b/src/mbgl/shader/raster_attributes.hpp deleted file mode 100644 index 88f0125754..0000000000 --- a/src/mbgl/shader/raster_attributes.hpp +++ /dev/null @@ -1,29 +0,0 @@ -#pragma once - -#include -#include - -namespace mbgl { - -struct RasterAttributes : gl::Attributes< - attributes::a_pos, - attributes::a_texture_pos> -{ - static Vertex vertex(Point p, Point t) { - return Vertex { - { - p.x, - p.y - }, - { - t.x, - t.y - } - }; - } -}; - -using RasterVertex = RasterAttributes::Vertex; -static_assert(sizeof(RasterVertex) == 8, "expected RasterVertex size"); - -} // namespace mbgl diff --git a/src/mbgl/shader/raster_shader.cpp b/src/mbgl/shader/raster_shader.cpp deleted file mode 100644 index 4f1d873044..0000000000 --- a/src/mbgl/shader/raster_shader.cpp +++ /dev/null @@ -1,16 +0,0 @@ -#include -#include -#include - -namespace mbgl { - -RasterShader::RasterShader(gl::Context& context, Defines defines) - : Shader(shaders::raster::name, - shaders::raster::vertex, - shaders::raster::fragment, - context, defines), - attributesState(RasterAttributes::state(*this)), - uniformsState(RasterUniforms::state(*this)) { -} - -} // namespace mbgl diff --git a/src/mbgl/shader/raster_shader.hpp b/src/mbgl/shader/raster_shader.hpp deleted file mode 100644 index 6d85175d77..0000000000 --- a/src/mbgl/shader/raster_shader.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { - -class RasterShader : public gl::Shader { -public: - RasterShader(gl::Context&, Defines defines = None); - - using AttributesType = RasterAttributes; - using UniformsType = RasterUniforms; - - typename RasterAttributes::State attributesState; - typename RasterUniforms::State uniformsState; -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/raster_uniforms.hpp b/src/mbgl/shader/raster_uniforms.hpp deleted file mode 100644 index 0a81b95c66..0000000000 --- a/src/mbgl/shader/raster_uniforms.hpp +++ /dev/null @@ -1,37 +0,0 @@ -#pragma once - -#include - -namespace mbgl { - -namespace uniforms { -MBGL_DEFINE_UNIFORM_SCALAR(gl::TextureUnit, u_image0); -MBGL_DEFINE_UNIFORM_SCALAR(gl::TextureUnit, u_image1); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_opacity0); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_opacity1); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_buffer_scale); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_brightness_low); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_brightness_high); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_saturation_factor); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_contrast_factor); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_scale_parent); -MBGL_DEFINE_UNIFORM_VECTOR(float, 3, u_spin_weights); -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_tl_parent); -} // namespace uniforms - -struct RasterUniforms : gl::Uniforms< - uniforms::u_matrix, - uniforms::u_image0, - uniforms::u_image1, - uniforms::u_opacity0, - uniforms::u_opacity1, - uniforms::u_brightness_low, - uniforms::u_brightness_high, - uniforms::u_saturation_factor, - uniforms::u_contrast_factor, - uniforms::u_spin_weights, - uniforms::u_buffer_scale, - uniforms::u_scale_parent, - uniforms::u_tl_parent> {}; - -} // namespace mbgl diff --git a/src/mbgl/shader/shaders.hpp b/src/mbgl/shader/shaders.hpp deleted file mode 100644 index 56b063ce29..0000000000 --- a/src/mbgl/shader/shaders.hpp +++ /dev/null @@ -1,53 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -namespace mbgl { - -class Shaders { -public: - Shaders(gl::Context& context, gl::Shader::Defines defines = gl::Shader::None) - : circle(context, defines), - fill(context, defines), - fillPattern(context, defines), - fillOutline(context, defines), - fillOutlinePattern(context, defines), - line(context, defines), - lineSDF(context, defines), - linePattern(context, defines), - raster(context, defines), - symbolIcon(context, defines), - symbolIconSDF(context, defines), - symbolGlyph(context, defines), - collisionBox(context) { - } - - CircleShader circle; - FillShader fill; - FillPatternShader fillPattern; - FillOutlineShader fillOutline; - FillOutlinePatternShader fillOutlinePattern; - LineShader line; - LineSDFShader lineSDF; - LinePatternShader linePattern; - RasterShader raster; - SymbolIconShader symbolIcon; - SymbolSDFShader symbolIconSDF; - SymbolSDFShader symbolGlyph; - - CollisionBoxShader collisionBox; -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/symbol_attributes.hpp b/src/mbgl/shader/symbol_attributes.hpp deleted file mode 100644 index 32f252e49a..0000000000 --- a/src/mbgl/shader/symbol_attributes.hpp +++ /dev/null @@ -1,50 +0,0 @@ -#pragma once - -#include -#include - -#include - -namespace mbgl { - -struct SymbolAttributes : gl::Attributes< - attributes::a_pos, - attributes::a_offset, - attributes::a_texture_pos, - attributes::a_data<4>> -{ - static Vertex vertex(Point a, - Point o, - uint16_t tx, - uint16_t ty, - float minzoom, - float maxzoom, - float labelminzoom, - uint8_t labelangle) { - return Vertex { - { - static_cast(a.x), - static_cast(a.y) - }, - { - static_cast(::round(o.x * 64)), // use 1/64 pixels for placement - static_cast(::round(o.y * 64)) - }, - { - static_cast(tx / 4), - static_cast(ty / 4) - }, - { - static_cast(labelminzoom * 10), // 1/10 zoom levels: z16 == 160 - static_cast(labelangle), - static_cast(minzoom * 10), - static_cast(::fmin(maxzoom, 25) * 10) - } - }; - } -}; - -using SymbolVertex = SymbolAttributes::Vertex; -static_assert(sizeof(SymbolVertex) == 16, "expected SymbolVertex size"); - -} // namespace mbgl diff --git a/src/mbgl/shader/symbol_icon_shader.cpp b/src/mbgl/shader/symbol_icon_shader.cpp deleted file mode 100644 index c6677eb38e..0000000000 --- a/src/mbgl/shader/symbol_icon_shader.cpp +++ /dev/null @@ -1,16 +0,0 @@ -#include -#include -#include - -namespace mbgl { - -SymbolIconShader::SymbolIconShader(gl::Context& context, Defines defines) - : Shader(shaders::symbol_icon::name, - shaders::symbol_icon::vertex, - shaders::symbol_icon::fragment, - context, defines), - attributesState(SymbolAttributes::state(*this)), - uniformsState(SymbolIconUniforms::state(*this)) { -} - -} // namespace mbgl diff --git a/src/mbgl/shader/symbol_icon_shader.hpp b/src/mbgl/shader/symbol_icon_shader.hpp deleted file mode 100644 index b04ae76d75..0000000000 --- a/src/mbgl/shader/symbol_icon_shader.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { - -class SymbolIconShader : public gl::Shader { -public: - SymbolIconShader(gl::Context&, Defines defines = None); - - using AttributesType = SymbolAttributes; - using UniformsType = SymbolIconUniforms; - - typename SymbolAttributes::State attributesState; - typename SymbolIconUniforms::State uniformsState; -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/symbol_sdf_shader.cpp b/src/mbgl/shader/symbol_sdf_shader.cpp deleted file mode 100644 index aeb45e1099..0000000000 --- a/src/mbgl/shader/symbol_sdf_shader.cpp +++ /dev/null @@ -1,16 +0,0 @@ -#include -#include -#include - -namespace mbgl { - -SymbolSDFShader::SymbolSDFShader(gl::Context& context, Defines defines) - : Shader(shaders::symbol_sdf::name, - shaders::symbol_sdf::vertex, - shaders::symbol_sdf::fragment, - context, defines), - attributesState(SymbolAttributes::state(*this)), - uniformsState(SymbolSDFUniforms::state(*this)) { -} - -} // namespace mbgl diff --git a/src/mbgl/shader/symbol_sdf_shader.hpp b/src/mbgl/shader/symbol_sdf_shader.hpp deleted file mode 100644 index 5ebfca5a43..0000000000 --- a/src/mbgl/shader/symbol_sdf_shader.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace mbgl { - -class SymbolSDFShader : public gl::Shader { -public: - SymbolSDFShader(gl::Context&, Defines defines = None); - - using AttributesType = SymbolAttributes; - using UniformsType = SymbolSDFUniforms; - - typename SymbolAttributes::State attributesState; - typename SymbolSDFUniforms::State uniformsState; -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/symbol_uniforms.cpp b/src/mbgl/shader/symbol_uniforms.cpp deleted file mode 100644 index ec2cf26c8a..0000000000 --- a/src/mbgl/shader/symbol_uniforms.cpp +++ /dev/null @@ -1,143 +0,0 @@ -#include -#include -#include -#include - -namespace mbgl { - -using namespace style; - -template -Values makeValues(const style::SymbolPropertyValues& values, - const Size& texsize, - const std::array& pixelsToGLUnits, - const RenderTile& tile, - const TransformState& state, - Args&&... args) { - std::array extrudeScale; - - const float scale = values.paintSize / values.sdfScale; - if (values.pitchAlignment == AlignmentType::Map) { - extrudeScale.fill(tile.id.pixelsToTileUnits(1, state.getZoom()) * scale); - } else { - extrudeScale = {{ - pixelsToGLUnits[0] * scale * state.getAltitude(), - pixelsToGLUnits[1] * scale * state.getAltitude() - }}; - } - - // adjust min/max zooms for variable font sies - float zoomAdjust = std::log(values.paintSize / values.layoutSize) / std::log(2); - - return Values { - uniforms::u_matrix::Value{ tile.translatedMatrix(values.translate, - values.translateAnchor, - state) }, - uniforms::u_opacity::Value{ values.opacity }, - uniforms::u_extrude_scale::Value{ extrudeScale }, - uniforms::u_texsize::Value{ std::array {{ float(texsize.width) / 4, float(texsize.height) / 4 }} }, - uniforms::u_zoom::Value{ float((state.getZoom() - zoomAdjust) * 10) }, - uniforms::u_rotate_with_map::Value{ values.rotationAlignment == AlignmentType::Map }, - uniforms::u_texture::Value{ 0 }, - uniforms::u_fadetexture::Value{ 1 }, - std::forward(args)... - }; -} - -SymbolIconUniforms::Values -SymbolIconUniforms::values(const style::SymbolPropertyValues& values, - const Size& texsize, - const std::array& pixelsToGLUnits, - const RenderTile& tile, - const TransformState& state) -{ - return makeValues( - values, - texsize, - pixelsToGLUnits, - tile, - state - ); -} - -static SymbolSDFUniforms::Values makeSDFValues(const style::SymbolPropertyValues& values, - const Size& texsize, - const std::array& pixelsToGLUnits, - const RenderTile& tile, - const TransformState& state, - float pixelRatio, - Color color, - float buffer, - float gammaAdjust) -{ - // The default gamma value has to be adjust for the current pixelratio so that we're not - // drawing blurry font on retina screens. - const float gammaBase = 0.105 * values.sdfScale / values.paintSize / pixelRatio; - const float gammaScale = values.pitchAlignment == AlignmentType::Map - ? 1.0 / std::cos(state.getPitch()) - : 1.0; - - return makeValues( - values, - texsize, - pixelsToGLUnits, - tile, - state, - uniforms::u_color::Value{ color }, - uniforms::u_buffer::Value{ buffer }, - uniforms::u_gamma::Value{ (gammaBase + gammaAdjust) * gammaScale }, - uniforms::u_pitch::Value{ state.getPitch() }, - uniforms::u_bearing::Value{ -1.0f * state.getAngle() }, - uniforms::u_aspect_ratio::Value{ (state.getSize().width * 1.0f) / (state.getSize().height * 1.0f) }, - uniforms::u_pitch_with_map::Value{ values.pitchAlignment == AlignmentType::Map } - ); -} - -SymbolSDFUniforms::Values -SymbolSDFUniforms::haloValues(const style::SymbolPropertyValues& values, - const Size& texsize, - const std::array& pixelsToGLUnits, - const RenderTile& tile, - const TransformState& state, - float pixelRatio) -{ - const float scale = values.paintSize / values.sdfScale; - const float sdfPx = 8.0f; - const float blurOffset = 1.19f; - const float haloOffset = 6.0f; - - return makeSDFValues( - values, - texsize, - pixelsToGLUnits, - tile, - state, - pixelRatio, - values.haloColor, - (haloOffset - values.haloWidth / scale) / sdfPx, - values.haloBlur * blurOffset / scale / sdfPx - ); -} - -SymbolSDFUniforms::Values -SymbolSDFUniforms::foregroundValues(const style::SymbolPropertyValues& values, - const Size& texsize, - const std::array& pixelsToGLUnits, - const RenderTile& tile, - const TransformState& state, - float pixelRatio) -{ - return makeSDFValues( - values, - texsize, - pixelsToGLUnits, - tile, - state, - pixelRatio, - values.color, - (256.0f - 64.0f) / 256.0f, - 0 - ); -} - -} // namespace mbgl diff --git a/src/mbgl/shader/symbol_uniforms.hpp b/src/mbgl/shader/symbol_uniforms.hpp deleted file mode 100644 index a38837c051..0000000000 --- a/src/mbgl/shader/symbol_uniforms.hpp +++ /dev/null @@ -1,77 +0,0 @@ -#pragma once - -#include -#include - -#include - -namespace mbgl { - -namespace style { -class SymbolPropertyValues; -} // namespace style - -class RenderTile; -class TransformState; - -namespace uniforms { -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_texsize); -MBGL_DEFINE_UNIFORM_SCALAR(bool, u_rotate_with_map); -MBGL_DEFINE_UNIFORM_SCALAR(bool, u_pitch_with_map); -MBGL_DEFINE_UNIFORM_SCALAR(gl::TextureUnit, u_texture); -MBGL_DEFINE_UNIFORM_SCALAR(gl::TextureUnit, u_fadetexture); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_buffer); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_gamma); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_aspect_ratio); -} // namespace uniforms - -struct SymbolIconUniforms : gl::Uniforms< - uniforms::u_matrix, - uniforms::u_opacity, - uniforms::u_extrude_scale, - uniforms::u_texsize, - uniforms::u_zoom, - uniforms::u_rotate_with_map, - uniforms::u_texture, - uniforms::u_fadetexture> -{ - static Values values(const style::SymbolPropertyValues&, - const Size& texsize, - const std::array& pixelsToGLUnits, - const RenderTile&, - const TransformState&); -}; - -struct SymbolSDFUniforms : gl::Uniforms< - uniforms::u_matrix, - uniforms::u_opacity, - uniforms::u_extrude_scale, - uniforms::u_texsize, - uniforms::u_zoom, - uniforms::u_rotate_with_map, - uniforms::u_texture, - uniforms::u_fadetexture, - uniforms::u_color, - uniforms::u_buffer, - uniforms::u_gamma, - uniforms::u_pitch, - uniforms::u_bearing, - uniforms::u_aspect_ratio, - uniforms::u_pitch_with_map> -{ - static Values haloValues(const style::SymbolPropertyValues&, - const Size& texsize, - const std::array& pixelsToGLUnits, - const RenderTile&, - const TransformState&, - float pixelRatio); - - static Values foregroundValues(const style::SymbolPropertyValues&, - const Size& texsize, - const std::array& pixelsToGLUnits, - const RenderTile&, - const TransformState&, - float pixelRatio); -}; - -} // namespace mbgl diff --git a/src/mbgl/shader/uniforms.hpp b/src/mbgl/shader/uniforms.hpp deleted file mode 100644 index e0c5a0d361..0000000000 --- a/src/mbgl/shader/uniforms.hpp +++ /dev/null @@ -1,33 +0,0 @@ -#pragma once - -#include -#include - -namespace mbgl { -namespace uniforms { - -// Uniforms common to several shaders. - -MBGL_DEFINE_UNIFORM_MATRIX(double, 4, u_matrix); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_opacity); -MBGL_DEFINE_UNIFORM_SCALAR(Color, u_color); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_blur); - -MBGL_DEFINE_UNIFORM_SCALAR(float, u_zoom); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_pitch); -MBGL_DEFINE_UNIFORM_SCALAR(float, u_bearing); - -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_extrude_scale); - -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_tl_a); -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_br_a); -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_tl_b); -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_br_b); -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_size_a); -MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_size_b); - -MBGL_DEFINE_UNIFORM_SCALAR(float, u_mix); -MBGL_DEFINE_UNIFORM_SCALAR(gl::TextureUnit, u_image); - -} // namespace uniforms -} // namespace mbgl diff --git a/test/gl/object.test.cpp b/test/gl/object.test.cpp index 45a69b4c71..fb143c55c8 100644 --- a/test/gl/object.test.cpp +++ b/test/gl/object.test.cpp @@ -7,6 +7,8 @@ #include +using namespace mbgl; + namespace { static bool getFlag = false; @@ -27,7 +29,7 @@ TEST(GLObject, PreserveState) { getFlag = false; setFlag = false; - auto object = std::make_unique>(); + auto object = std::make_unique>(); EXPECT_TRUE(getFlag); EXPECT_FALSE(setFlag); @@ -40,7 +42,7 @@ TEST(GLObject, PreserveState) { TEST(GLObject, Value) { setFlag = false; - auto object = std::make_unique>(); + auto object = std::make_unique>(); EXPECT_EQ(object->getCurrentValue(), false); EXPECT_TRUE(object->isDirty()); EXPECT_FALSE(setFlag); @@ -58,27 +60,13 @@ TEST(GLObject, Value) { } TEST(GLObject, Store) { - mbgl::HeadlessBackend backend; - mbgl::OffscreenView view(backend.getContext()); - - mbgl::gl::Context context; - EXPECT_TRUE(context.empty()); + HeadlessBackend backend; + OffscreenView view(backend.getContext()); - mbgl::gl::UniqueProgram program = context.createProgram(); - EXPECT_NE(program.get(), 0u); - program.reset(); - EXPECT_FALSE(context.empty()); - context.performCleanup(); - EXPECT_TRUE(context.empty()); - - mbgl::gl::UniqueShader shader = context.createVertexShader(); - EXPECT_NE(shader.get(), 0u); - shader.reset(); - EXPECT_FALSE(context.empty()); - context.performCleanup(); + gl::Context context; EXPECT_TRUE(context.empty()); - mbgl::gl::UniqueTexture texture = context.createTexture(); + gl::UniqueTexture texture = context.createTexture(); EXPECT_NE(texture.get(), 0u); texture.reset(); EXPECT_FALSE(context.empty()); -- cgit v1.2.1