[core] Introduce gl::Program template

This commit is contained in:
John Firebaugh
2016-10-28 18:17:33 -07:00
parent 36210fe4e9
commit 66bdbc3b96
90 changed files with 984 additions and 1451 deletions

View File

@@ -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

View File

@@ -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)

View File

@@ -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

View File

@@ -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

View File

@@ -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 <mbgl/gl/gl.hpp>\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 <mbgl/gl/gl.hpp>\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);

View File

@@ -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,

View File

@@ -1,7 +1,6 @@
#pragma once
#include <mbgl/gl/types.hpp>
#include <mbgl/gl/shader.hpp>
#include <cstddef>
#include <functional>
@@ -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<T>::value;
@@ -134,6 +130,8 @@ const std::size_t Vertex<A1, A2, A3, A4, A5>::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<typename As::State...>;
using Vertex = detail::Vertex<As...>;
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<void (std::size_t)> binder(const State& state) {

View File

@@ -4,12 +4,16 @@
#include <mbgl/gl/vertex_array.hpp>
#include <mbgl/util/traits.hpp>
#include <mbgl/util/std.hpp>
#include <mbgl/platform/log.hpp>
#include <boost/functional/hash.hpp>
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<GLenum>(type))), { this } };
const GLchar* sources = source.data();
const GLsizei lengths = static_cast<GLsizei>(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<GLchar[]>(logLength);
MBGL_CHECK_ERROR(glGetShaderInfoLog(result, logLength, &logLength, log.get()));
Log::Error(Event::Shader, "Shader failed to compile: %s", log.get());
}
throw std::runtime_error("shader failed to compile");
}
UniqueShader Context::createVertexShader() {
return UniqueShader{ MBGL_CHECK_ERROR(glCreateShader(GL_VERTEX_SHADER)), { this } };
}
UniqueProgram Context::createProgram(ShaderID vertexShader, ShaderID fragmentShader) {
UniqueProgram result { MBGL_CHECK_ERROR(glCreateProgram()), { this } };
UniqueShader Context::createFragmentShader() {
return UniqueShader{ MBGL_CHECK_ERROR(glCreateShader(GL_FRAGMENT_SHADER)), { 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<GLchar[]>(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) {

View File

@@ -14,6 +14,7 @@
#include <memory>
#include <vector>
#include <array>
#include <string>
#include <unordered_map>
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 <class V>

View File

@@ -82,28 +82,28 @@ auto Segmented(const VertexBuffer<Vertex>& vertexBuffer,
class Drawable {
public:
template <class Shader, class Subject>
template <class Program, class Subject>
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<typename Subject::VertexType>::value, "vertex type must use standard layout");
static_assert(std::is_same<typename Shader::AttributesType::Vertex, typename Subject::VertexType>::value, "vertex type mismatch");
static_assert(std::is_standard_layout<typename Program::Vertex>::value, "vertex type must use standard layout");
static_assert(std::is_same<typename Program::Vertex, typename Subject::VertexType>::value, "vertex type mismatch");
}
DrawMode drawMode;

37
src/mbgl/gl/program.hpp Normal file
View File

@@ -0,0 +1,37 @@
#pragma once
#include <mbgl/gl/types.hpp>
#include <mbgl/gl/object.hpp>
#include <mbgl/gl/context.hpp>
#include <string>
namespace mbgl {
namespace gl {
template <class As, class Us>
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

View File

@@ -1,113 +0,0 @@
#include <mbgl/gl/shader.hpp>
#include <mbgl/gl/gl.hpp>
#include <mbgl/gl/context.hpp>
#include <mbgl/util/stopwatch.hpp>
#include <mbgl/util/exception.hpp>
#include <mbgl/platform/log.hpp>
#include <mbgl/platform/platform.hpp>
#include <cstring>
#include <cassert>
#include <iostream>
#include <string>
#include <fstream>
#include <cstdio>
#include <cassert>
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<GLchar[]>(logLength);
if (logLength > 0) {
MBGL_CHECK_ERROR(glGetProgramInfoLog(program.get(), logLength, &logLength, log.get()));
Log::Error(Event::Shader, "Program failed to link: %s", log.get());
}
throw util::ShaderException(std::string { "Program " } + name + " failed to link: " + log.get());
}
}
bool Shader::compileShader(UniqueShader& shader, const GLchar *source) {
GLint status = 0;
const GLsizei lengths = static_cast<GLsizei>(std::strlen(source));
MBGL_CHECK_ERROR(glShaderSource(shader.get(), 1, &source, &lengths));
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<GLchar[]>(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

View File

@@ -1,45 +0,0 @@
#pragma once
#include <mbgl/gl/types.hpp>
#include <mbgl/gl/object.hpp>
#include <mbgl/util/noncopyable.hpp>
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

View File

@@ -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,

View File

@@ -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<float>(UniformLocation location, const float& t) {
MBGL_CHECK_ERROR(glUniform1f(location, t));

View File

@@ -1,6 +1,6 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/gl/types.hpp>
#include <mbgl/util/optional.hpp>
#include <array>
@@ -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<T> current;
UniformLocation location;
optional<T> current = {};
};
};
@@ -61,14 +57,16 @@ using UniformMatrix = Uniform<Tag, std::array<T, N*N>>;
#define MBGL_DEFINE_UNIFORM_MATRIX(type_, n_, name_) \
struct name_ : ::mbgl::gl::UniformMatrix<name_, type_, n_> { static constexpr auto name = #name_; }
UniformLocation uniformLocation(ProgramID, const char * name);
template <class... Us>
class Uniforms {
public:
using State = std::tuple<typename Us::State...>;
using Values = std::tuple<typename Us::Value...>;
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<void ()> binder(State& state, Values&& values_) {

View File

@@ -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);

View File

@@ -0,0 +1,7 @@
#include <mbgl/programs/circle_program.hpp>
namespace mbgl {
static_assert(sizeof(CircleProgram::Vertex) == 4, "expected CircleVertex size");
} // namespace mbgl

View File

@@ -0,0 +1,52 @@
#pragma once
#include <mbgl/programs/program.hpp>
#include <mbgl/programs/attributes.hpp>
#include <mbgl/programs/uniforms.hpp>
#include <mbgl/shader/circle.hpp>
#include <mbgl/util/geometry.hpp>
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<int16_t> p, float ex, float ey) {
return Vertex {
{
static_cast<int16_t>((p.x * 2) + ((ex + 1) / 2)),
static_cast<int16_t>((p.y * 2) + ((ey + 1) / 2))
}
};
}
};
using CircleVertex = CircleProgram::Vertex;
} // namespace mbgl

View File

@@ -0,0 +1,7 @@
#include <mbgl/programs/collision_box_program.hpp>
namespace mbgl {
static_assert(sizeof(CollisionBoxProgram::Vertex) == 10, "expected CollisionBoxVertex size");
} // namespace mbgl

View File

@@ -0,0 +1,53 @@
#pragma once
#include <mbgl/programs/program.hpp>
#include <mbgl/programs/attributes.hpp>
#include <mbgl/programs/uniforms.hpp>
#include <mbgl/shader/collision_box.hpp>
#include <mbgl/util/geometry.hpp>
#include <cmath>
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<float> a, Point<float> o, float maxzoom, float placementZoom) {
return Vertex {
{
static_cast<int16_t>(a.x),
static_cast<int16_t>(a.y)
},
{
static_cast<int16_t>(::round(o.x)),
static_cast<int16_t>(::round(o.y))
},
{
static_cast<uint8_t>(maxzoom * 10),
static_cast<uint8_t>(placementZoom * 10)
}
};
}
};
using CollisionBoxVertex = CollisionBoxProgram::Vertex;
} // namespace mbgl

View File

@@ -1,4 +1,4 @@
#include <mbgl/shader/fill_uniforms.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/sprite/sprite_atlas.hpp>
#include <mbgl/style/property_evaluator.hpp>
#include <mbgl/tile/tile_id.hpp>
@@ -8,6 +8,8 @@ namespace mbgl {
using namespace style;
static_assert(sizeof(FillAttributes::Vertex) == 4, "expected FillVertex size");
FillPatternUniforms::Values
FillPatternUniforms::values(mat4 matrix,
float opacity,

View File

@@ -1,6 +1,13 @@
#pragma once
#include <mbgl/shader/uniforms.hpp>
#include <mbgl/programs/program.hpp>
#include <mbgl/programs/attributes.hpp>
#include <mbgl/programs/uniforms.hpp>
#include <mbgl/shader/fill.hpp>
#include <mbgl/shader/fill_pattern.hpp>
#include <mbgl/shader/fill_outline.hpp>
#include <mbgl/shader/fill_outline_pattern.hpp>
#include <mbgl/util/geometry.hpp>
#include <mbgl/util/mat4.hpp>
#include <mbgl/util/size.hpp>
@@ -8,6 +15,14 @@
namespace mbgl {
class SpriteAtlasPosition;
class UnwrappedTileID;
class TransformState;
namespace style {
template <class> class Faded;
} // namespace style
namespace uniforms {
MBGL_DEFINE_UNIFORM_SCALAR(Size, u_world);
MBGL_DEFINE_UNIFORM_SCALAR(Color, u_outline_color);
@@ -18,20 +33,28 @@ 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<
struct FillAttributes : gl::Attributes<
attributes::a_pos>
{
static Vertex vertex(Point<int16_t> 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> {};
class SpriteAtlasPosition;
class UnwrappedTileID;
class TransformState;
namespace style {
template <class> class Faded;
} // namespace style
uniforms::u_world>
{};
struct FillPatternUniforms : gl::Uniforms<
uniforms::u_matrix,
@@ -49,7 +72,8 @@ struct FillPatternUniforms : gl::Uniforms<
uniforms::u_image,
uniforms::u_pixel_coord_upper,
uniforms::u_pixel_coord_lower,
uniforms::u_tile_units_to_pixels> {
uniforms::u_tile_units_to_pixels>
{
static Values values(mat4 matrix,
float opacity,
Size framebufferSize,
@@ -60,4 +84,36 @@ struct FillPatternUniforms : gl::Uniforms<
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

View File

@@ -1,4 +1,4 @@
#include <mbgl/shader/line_uniforms.hpp>
#include <mbgl/programs/line_program.hpp>
#include <mbgl/style/layers/line_layer_properties.hpp>
#include <mbgl/renderer/render_tile.hpp>
#include <mbgl/map/transform_state.hpp>
@@ -8,6 +8,8 @@
namespace mbgl {
static_assert(sizeof(LineAttributes::Vertex) == 8, "expected LineVertex size");
template <class Values, class...Args>
Values makeValues(const style::LinePaintProperties& properties,
float pixelRatio,
@@ -45,12 +47,12 @@ Values makeValues(const style::LinePaintProperties& properties,
};
}
LineColorUniforms::Values
LineColorUniforms::values(const style::LinePaintProperties& properties,
float pixelRatio,
const RenderTile& tile,
const TransformState& state) {
return makeValues<LineColorUniforms::Values>(
LineProgram::UniformValues
LineProgram::uniformValues(const style::LinePaintProperties& properties,
float pixelRatio,
const RenderTile& tile,
const TransformState& state) {
return makeValues<LineProgram::UniformValues>(
properties,
pixelRatio,
tile,
@@ -59,15 +61,15 @@ LineColorUniforms::values(const style::LinePaintProperties& properties,
);
}
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) {
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;
@@ -81,7 +83,7 @@ LineSDFUniforms::values(const style::LinePaintProperties& properties,
-posB.height / 2.0f
}};
return makeValues<LineSDFUniforms::Values>(
return makeValues<LineSDFProgram::UniformValues>(
properties,
pixelRatio,
tile,
@@ -97,13 +99,13 @@ LineSDFUniforms::values(const style::LinePaintProperties& properties,
);
}
LinePatternUniforms::Values
LinePatternUniforms::values(const style::LinePaintProperties& properties,
float pixelRatio,
const RenderTile& tile,
const TransformState& state,
const SpriteAtlasPosition& posA,
const SpriteAtlasPosition& posB) {
LinePatternProgram::UniformValues
LinePatternProgram::uniformValues(const style::LinePaintProperties& properties,
float pixelRatio,
const RenderTile& tile,
const TransformState& state,
const SpriteAtlasPosition& posA,
const SpriteAtlasPosition& posB) {
std::array<float, 2> sizeA {{
tile.id.pixelsToTileUnits(posA.size[0] * properties.linePattern.value.fromScale, state.getIntegerZoom()),
posA.size[1]
@@ -114,7 +116,7 @@ LinePatternUniforms::values(const style::LinePaintProperties& properties,
posB.size[1]
}};
return makeValues<LinePatternUniforms::Values>(
return makeValues<LinePatternProgram::UniformValues>(
properties,
pixelRatio,
tile,

View File

@@ -0,0 +1,184 @@
#pragma once
#include <mbgl/programs/program.hpp>
#include <mbgl/programs/attributes.hpp>
#include <mbgl/programs/uniforms.hpp>
#include <mbgl/shader/line.hpp>
#include <mbgl/shader/line_pattern.hpp>
#include <mbgl/shader/line_sdf.hpp>
#include <mbgl/util/geometry.hpp>
#include <cmath>
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<int16_t> p, Point<double> e, Point<bool> t, int8_t dir, int32_t linesofar = 0) {
return Vertex {
{
static_cast<int16_t>((p.x * 2) | t.x),
static_cast<int16_t>((p.y * 2) | t.y)
},
{
// add 128 to store an byte in an unsigned byte
static_cast<uint8_t>(::round(extrudeScale * e.x) + 128),
static_cast<uint8_t>(::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<uint8_t>(((dir == 0 ? 0 : (dir < 0 ? -1 : 1 )) + 1) | ((linesofar & 0x3F) << 2)),
static_cast<uint8_t>(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

View File

@@ -0,0 +1,31 @@
#pragma once
#include <mbgl/gl/program.hpp>
#include <cassert>
namespace mbgl {
enum class ProgramDefines : bool {
None = false,
Overdraw = true,
};
template <class Shaders, class As, class Us>
class Program : public gl::Program<As, Us> {
public:
Program(gl::Context& context, ProgramDefines defines)
: gl::Program<As, Us>(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

View File

@@ -0,0 +1,46 @@
#pragma once
#include <mbgl/programs/circle_program.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/programs/line_program.hpp>
#include <mbgl/programs/raster_program.hpp>
#include <mbgl/programs/symbol_program.hpp>
#include <mbgl/programs/collision_box_program.hpp>
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

View File

@@ -0,0 +1,7 @@
#include <mbgl/programs/raster_program.hpp>
namespace mbgl {
static_assert(sizeof(RasterProgram::Vertex) == 8, "expected RasterVertex size");
} // namespace mbgl

View File

@@ -0,0 +1,65 @@
#pragma once
#include <mbgl/programs/program.hpp>
#include <mbgl/programs/attributes.hpp>
#include <mbgl/programs/uniforms.hpp>
#include <mbgl/shader/raster.hpp>
#include <mbgl/util/geometry.hpp>
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<int16_t> p, Point<uint16_t> t) {
return Vertex {
{
p.x,
p.y
},
{
t.x,
t.y
}
};
}
};
using RasterVertex = RasterProgram::Vertex;
} // namespace mbgl

View File

@@ -1,4 +1,4 @@
#include <mbgl/shader/symbol_uniforms.hpp>
#include <mbgl/programs/symbol_program.hpp>
#include <mbgl/renderer/render_tile.hpp>
#include <mbgl/map/transform_state.hpp>
#include <mbgl/style/layers/symbol_layer_impl.hpp>
@@ -7,6 +7,8 @@ namespace mbgl {
using namespace style;
static_assert(sizeof(SymbolAttributes::Vertex) == 16, "expected SymbolVertex size");
template <class Values, class...Args>
Values makeValues(const style::SymbolPropertyValues& values,
const Size& texsize,
@@ -44,14 +46,14 @@ Values makeValues(const style::SymbolPropertyValues& values,
};
}
SymbolIconUniforms::Values
SymbolIconUniforms::values(const style::SymbolPropertyValues& values,
const Size& texsize,
const std::array<float, 2>& pixelsToGLUnits,
const RenderTile& tile,
const TransformState& state)
SymbolIconProgram::UniformValues
SymbolIconProgram::uniformValues(const style::SymbolPropertyValues& values,
const Size& texsize,
const std::array<float, 2>& pixelsToGLUnits,
const RenderTile& tile,
const TransformState& state)
{
return makeValues<SymbolIconUniforms::Values>(
return makeValues<SymbolIconProgram::UniformValues>(
values,
texsize,
pixelsToGLUnits,
@@ -60,7 +62,7 @@ SymbolIconUniforms::values(const style::SymbolPropertyValues& values,
);
}
static SymbolSDFUniforms::Values makeSDFValues(const style::SymbolPropertyValues& values,
static SymbolSDFProgram::UniformValues makeSDFValues(const style::SymbolPropertyValues& values,
const Size& texsize,
const std::array<float, 2>& pixelsToGLUnits,
const RenderTile& tile,
@@ -77,7 +79,7 @@ static SymbolSDFUniforms::Values makeSDFValues(const style::SymbolPropertyValues
? 1.0 / std::cos(state.getPitch())
: 1.0;
return makeValues<SymbolSDFUniforms::Values>(
return makeValues<SymbolSDFProgram::UniformValues>(
values,
texsize,
pixelsToGLUnits,
@@ -93,8 +95,8 @@ static SymbolSDFUniforms::Values makeSDFValues(const style::SymbolPropertyValues
);
}
SymbolSDFUniforms::Values
SymbolSDFUniforms::haloValues(const style::SymbolPropertyValues& values,
SymbolSDFProgram::UniformValues
SymbolSDFProgram::haloUniformValues(const style::SymbolPropertyValues& values,
const Size& texsize,
const std::array<float, 2>& pixelsToGLUnits,
const RenderTile& tile,
@@ -119,8 +121,8 @@ SymbolSDFUniforms::haloValues(const style::SymbolPropertyValues& values,
);
}
SymbolSDFUniforms::Values
SymbolSDFUniforms::foregroundValues(const style::SymbolPropertyValues& values,
SymbolSDFProgram::UniformValues
SymbolSDFProgram::foregroundUniformValues(const style::SymbolPropertyValues& values,
const Size& texsize,
const std::array<float, 2>& pixelsToGLUnits,
const RenderTile& tile,

View File

@@ -0,0 +1,134 @@
#pragma once
#include <mbgl/programs/program.hpp>
#include <mbgl/programs/attributes.hpp>
#include <mbgl/programs/uniforms.hpp>
#include <mbgl/shader/symbol_icon.hpp>
#include <mbgl/shader/symbol_sdf.hpp>
#include <mbgl/util/geometry.hpp>
#include <mbgl/util/size.hpp>
#include <cmath>
#include <array>
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<float> a,
Point<float> o,
uint16_t tx,
uint16_t ty,
float minzoom,
float maxzoom,
float labelminzoom,
uint8_t labelangle) {
return Vertex {
{
static_cast<int16_t>(a.x),
static_cast<int16_t>(a.y)
},
{
static_cast<int16_t>(::round(o.x * 64)), // use 1/64 pixels for placement
static_cast<int16_t>(::round(o.y * 64))
},
{
static_cast<uint16_t>(tx / 4),
static_cast<uint16_t>(ty / 4)
},
{
static_cast<uint8_t>(labelminzoom * 10), // 1/10 zoom levels: z16 == 160
static_cast<uint8_t>(labelangle),
static_cast<uint8_t>(minzoom * 10),
static_cast<uint8_t>(::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<float, 2>& 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<float, 2>& pixelsToGLUnits,
const RenderTile&,
const TransformState&,
float pixelRatio);
static UniformValues foregroundUniformValues(const style::SymbolPropertyValues&,
const Size& texsize,
const std::array<float, 2>& pixelsToGLUnits,
const RenderTile&,
const TransformState&,
float pixelRatio);
};
} // namespace mbgl

View File

@@ -2,7 +2,7 @@
#include <mbgl/renderer/painter.hpp>
#include <mbgl/gl/context.hpp>
#include <mbgl/shader/circle_shader.hpp>
#include <mbgl/programs/circle_program.hpp>
#include <mbgl/style/layers/circle_layer.hpp>
#include <mbgl/util/constants.hpp>
@@ -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<uint16_t>::max());

View File

@@ -6,7 +6,7 @@
#include <mbgl/gl/vertex_buffer.hpp>
#include <mbgl/gl/index_buffer.hpp>
#include <mbgl/gl/segment.hpp>
#include <mbgl/shader/circle_attributes.hpp>
#include <mbgl/programs/circle_program.hpp>
namespace mbgl {

View File

@@ -1,7 +1,6 @@
#include <mbgl/renderer/debug_bucket.hpp>
#include <mbgl/renderer/painter.hpp>
#include <mbgl/shader/fill_shader.hpp>
#include <mbgl/shader/fill_attributes.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/geometry/debug_font_data.hpp>
#include <mbgl/util/string.hpp>

View File

@@ -6,7 +6,7 @@
#include <mbgl/util/optional.hpp>
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/gl/vertex_buffer.hpp>
#include <mbgl/shader/fill_attributes.hpp>
#include <mbgl/programs/fill_program.hpp>
namespace mbgl {

View File

@@ -1,10 +1,7 @@
#include <mbgl/renderer/fill_bucket.hpp>
#include <mbgl/style/layers/fill_layer.hpp>
#include <mbgl/renderer/painter.hpp>
#include <mbgl/shader/fill_shader.hpp>
#include <mbgl/shader/fill_pattern_shader.hpp>
#include <mbgl/shader/fill_outline_shader.hpp>
#include <mbgl/shader/fill_outline_pattern_shader.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/platform/log.hpp>
#include <mapbox/earcut.hpp>

View File

@@ -5,7 +5,7 @@
#include <mbgl/gl/vertex_buffer.hpp>
#include <mbgl/gl/index_buffer.hpp>
#include <mbgl/gl/segment.hpp>
#include <mbgl/shader/fill_attributes.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <vector>

View File

@@ -5,7 +5,7 @@
#include <mbgl/gl/vertex_buffer.hpp>
#include <mbgl/gl/index_buffer.hpp>
#include <mbgl/gl/segment.hpp>
#include <mbgl/shader/line_attributes.hpp>
#include <mbgl/programs/line_program.hpp>
#include <mbgl/style/layers/line_layer_properties.hpp>
#include <vector>

View File

@@ -2,12 +2,12 @@
namespace mbgl {
class Shaders;
class Programs;
class View;
class PaintParameters {
public:
Shaders& shaders;
Programs& programs;
View& view;
};

View File

@@ -21,7 +21,7 @@
#include <mbgl/geometry/line_atlas.hpp>
#include <mbgl/text/glyph_atlas.hpp>
#include <mbgl/shader/shaders.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/algorithm/generate_clip_ids.hpp>
#include <mbgl/algorithm/generate_clip_ids_impl.hpp>
@@ -60,18 +60,18 @@ Painter::Painter(gl::Context& context_, const TransformState& state_)
FillAttributes::vertex({ 0, 0 })
}})),
rasterVertexBuffer(context.createVertexBuffer(std::vector<RasterVertex> {{
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<Shaders>(context);
programs = std::make_unique<Programs>(context);
#ifndef NDEBUG
overdrawShaders = std::make_unique<Shaders>(context, gl::Shader::Overdraw);
overdrawPrograms = std::make_unique<Programs>(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
};

View File

@@ -9,8 +9,8 @@
#include <mbgl/renderer/bucket.hpp>
#include <mbgl/gl/context.hpp>
#include <mbgl/shader/fill_attributes.hpp>
#include <mbgl/shader/raster_attributes.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/programs/raster_program.hpp>
#include <mbgl/style/style.hpp>
@@ -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> shaders;
std::unique_ptr<Programs> programs;
#ifndef NDEBUG
std::unique_ptr<Shaders> overdrawShaders;
std::unique_ptr<Programs> overdrawPrograms;
#endif
gl::VertexBuffer<FillVertex> tileTriangleVertexBuffer;

View File

@@ -2,8 +2,8 @@
#include <mbgl/renderer/paint_parameters.hpp>
#include <mbgl/style/layers/background_layer.hpp>
#include <mbgl/style/layers/background_layer_impl.hpp>
#include <mbgl/shader/shaders.hpp>
#include <mbgl/shader/fill_uniforms.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/sprite/sprite_atlas.hpp>
#include <mbgl/util/tile_cover.hpp>
@@ -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 },

View File

@@ -4,8 +4,8 @@
#include <mbgl/renderer/render_tile.hpp>
#include <mbgl/style/layers/circle_layer.hpp>
#include <mbgl/style/layers/circle_layer_impl.hpp>
#include <mbgl/shader/shaders.hpp>
#include <mbgl/shader/circle_uniforms.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/circle_program.hpp>
#include <mbgl/gl/context.hpp>
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) },

View File

@@ -1,6 +1,6 @@
#include <mbgl/renderer/painter.hpp>
#include <mbgl/shader/shaders.hpp>
#include <mbgl/shader/fill_uniforms.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/util/clip_id.hpp>
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 {} },

View File

@@ -4,8 +4,8 @@
#include <mbgl/renderer/paint_parameters.hpp>
#include <mbgl/map/view.hpp>
#include <mbgl/tile/tile.hpp>
#include <mbgl/shader/shaders.hpp>
#include <mbgl/shader/fill_uniforms.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/util/string.hpp>
#include <mbgl/gl/debugging.hpp>
#include <mbgl/util/color.hpp>
@@ -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 },

View File

@@ -5,8 +5,8 @@
#include <mbgl/style/layers/fill_layer.hpp>
#include <mbgl/style/layers/fill_layer_impl.hpp>
#include <mbgl/sprite/sprite_atlas.hpp>
#include <mbgl/shader/shaders.hpp>
#include <mbgl/shader/fill_uniforms.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/fill_program.hpp>
#include <mbgl/util/convert.hpp>
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<gl::Triangles>(
*bucket.vertexBuffer,
*bucket.triangleIndexBuffer,
@@ -69,20 +69,20 @@ void Painter::renderFill(PaintParameters& parameters,
}
draw(2,
parameters.shaders.fillOutlinePattern,
parameters.programs.fillOutlinePattern,
gl::Segmented<gl::Lines>(
*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<gl::Lines>(
*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<gl::Triangles>(
*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<gl::Lines>(
*bucket.vertexBuffer,

View File

@@ -4,8 +4,8 @@
#include <mbgl/renderer/render_tile.hpp>
#include <mbgl/style/layers/line_layer.hpp>
#include <mbgl/style/layers/line_layer_impl.hpp>
#include <mbgl/shader/shaders.hpp>
#include <mbgl/shader/line_uniforms.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/line_program.hpp>
#include <mbgl/sprite/sprite_atlas.hpp>
#include <mbgl/geometry/line_atlas.hpp>
@@ -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<gl::Triangles>(
*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,

View File

@@ -4,8 +4,8 @@
#include <mbgl/renderer/raster_bucket.hpp>
#include <mbgl/style/layers/raster_layer.hpp>
#include <mbgl/style/layers/raster_layer_impl.hpp>
#include <mbgl/shader/shaders.hpp>
#include <mbgl/shader/raster_uniforms.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/raster_program.hpp>
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 },

View File

@@ -6,9 +6,9 @@
#include <mbgl/style/layers/symbol_layer_impl.hpp>
#include <mbgl/text/glyph_atlas.hpp>
#include <mbgl/sprite/sprite_atlas.hpp>
#include <mbgl/shader/shaders.hpp>
#include <mbgl/shader/symbol_uniforms.hpp>
#include <mbgl/shader/collision_box_uniforms.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/symbol_program.hpp>
#include <mbgl/programs/collision_box_program.hpp>
#include <mbgl/util/math.hpp>
#include <mbgl/tile/tile.hpp>
@@ -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<gl::Triangles>(
*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) },

View File

@@ -1,6 +1,6 @@
#include <mbgl/renderer/raster_bucket.hpp>
#include <mbgl/style/layers/raster_layer.hpp>
#include <mbgl/shader/raster_shader.hpp>
#include <mbgl/programs/raster_program.hpp>
#include <mbgl/renderer/painter.hpp>
#include <mbgl/gl/context.hpp>

View File

@@ -5,8 +5,8 @@
#include <mbgl/gl/vertex_buffer.hpp>
#include <mbgl/gl/index_buffer.hpp>
#include <mbgl/gl/segment.hpp>
#include <mbgl/shader/symbol_attributes.hpp>
#include <mbgl/shader/collision_box_attributes.hpp>
#include <mbgl/programs/symbol_program.hpp>
#include <mbgl/programs/collision_box_program.hpp>
#include <mbgl/text/glyph_range.hpp>
#include <mbgl/style/layers/symbol_layer_properties.hpp>

View File

@@ -1,30 +0,0 @@
#pragma once
#include <mbgl/shader/attributes.hpp>
#include <mbgl/util/geometry.hpp>
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<int16_t> p, float ex, float ey) {
return Vertex {
{
static_cast<int16_t>((p.x * 2) + ((ex + 1) / 2)),
static_cast<int16_t>((p.y * 2) + ((ey + 1) / 2))
}
};
}
};
using CircleVertex = CircleAttributes::Vertex;
static_assert(sizeof(CircleVertex) == 4, "expected CircleVertex size");
} // namespace mbgl

View File

@@ -1,16 +0,0 @@
#include <mbgl/shader/circle_shader.hpp>
#include <mbgl/shader/circle.vertex.hpp>
#include <mbgl/shader/circle.fragment.hpp>
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

View File

@@ -1,20 +0,0 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/shader/circle_attributes.hpp>
#include <mbgl/shader/circle_uniforms.hpp>
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

View File

@@ -1,23 +0,0 @@
#pragma once
#include <mbgl/shader/uniforms.hpp>
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

View File

@@ -1,36 +0,0 @@
#pragma once
#include <mbgl/shader/attributes.hpp>
#include <mbgl/util/geometry.hpp>
#include <cmath>
namespace mbgl {
struct CollisionBoxAttributes : gl::Attributes<
attributes::a_pos,
attributes::a_extrude,
attributes::a_data<2>>
{
static Vertex vertex(Point<float> a, Point<float> o, float maxzoom, float placementZoom) {
return Vertex {
{
static_cast<int16_t>(a.x),
static_cast<int16_t>(a.y)
},
{
static_cast<int16_t>(::round(o.x)),
static_cast<int16_t>(::round(o.y))
},
{
static_cast<uint8_t>(maxzoom * 10),
static_cast<uint8_t>(placementZoom * 10)
}
};
}
};
using CollisionBoxVertex = CollisionBoxAttributes::Vertex;
static_assert(sizeof(CollisionBoxVertex) == 10, "expected CollisionBoxVertex size");
} // namespace mbgl

View File

@@ -1,17 +0,0 @@
#include <mbgl/shader/collision_box_shader.hpp>
#include <mbgl/shader/collision_box.vertex.hpp>
#include <mbgl/shader/collision_box.fragment.hpp>
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

View File

@@ -1,20 +0,0 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/shader/collision_box_uniforms.hpp>
#include <mbgl/shader/collision_box_attributes.hpp>
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

View File

@@ -1,18 +0,0 @@
#pragma once
#include <mbgl/shader/uniforms.hpp>
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

View File

@@ -1,24 +0,0 @@
#pragma once
#include <mbgl/shader/attributes.hpp>
#include <mbgl/util/geometry.hpp>
namespace mbgl {
struct FillAttributes : gl::Attributes<
attributes::a_pos> {
static Vertex vertex(Point<int16_t> p) {
return Vertex {
{
p.x,
p.y
}
};
}
};
using FillVertex = FillAttributes::Vertex;
static_assert(sizeof(FillVertex) == 4, "expected FillVertex size");
} // namespace mbgl

View File

@@ -1,16 +0,0 @@
#include <mbgl/shader/fill_outline_pattern_shader.hpp>
#include <mbgl/shader/fill_outline_pattern.vertex.hpp>
#include <mbgl/shader/fill_outline_pattern.fragment.hpp>
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

View File

@@ -1,20 +0,0 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/shader/fill_uniforms.hpp>
#include <mbgl/shader/fill_attributes.hpp>
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

View File

@@ -1,16 +0,0 @@
#include <mbgl/shader/fill_outline_shader.hpp>
#include <mbgl/shader/fill_outline.vertex.hpp>
#include <mbgl/shader/fill_outline.fragment.hpp>
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

View File

@@ -1,20 +0,0 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/shader/fill_uniforms.hpp>
#include <mbgl/shader/fill_attributes.hpp>
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

View File

@@ -1,16 +0,0 @@
#include <mbgl/shader/fill_pattern_shader.hpp>
#include <mbgl/shader/fill_pattern.vertex.hpp>
#include <mbgl/shader/fill_pattern.fragment.hpp>
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

View File

@@ -1,20 +0,0 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/shader/fill_uniforms.hpp>
#include <mbgl/shader/fill_attributes.hpp>
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

View File

@@ -1,16 +0,0 @@
#include <mbgl/shader/fill_shader.hpp>
#include <mbgl/shader/fill.vertex.hpp>
#include <mbgl/shader/fill.fragment.hpp>
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

View File

@@ -1,20 +0,0 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/shader/fill_uniforms.hpp>
#include <mbgl/shader/fill_attributes.hpp>
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

View File

@@ -1,60 +0,0 @@
#pragma once
#include <mbgl/shader/attributes.hpp>
#include <mbgl/util/geometry.hpp>
#include <cmath>
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<int16_t> p, Point<double> e, Point<bool> t, int8_t dir, int32_t linesofar = 0) {
return Vertex {
{
static_cast<int16_t>((p.x * 2) | t.x),
static_cast<int16_t>((p.y * 2) | t.y)
},
{
// add 128 to store an byte in an unsigned byte
static_cast<uint8_t>(::round(extrudeScale * e.x) + 128),
static_cast<uint8_t>(::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<uint8_t>(((dir == 0 ? 0 : (dir < 0 ? -1 : 1 )) + 1) | ((linesofar & 0x3F) << 2)),
static_cast<uint8_t>(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

View File

@@ -1,16 +0,0 @@
#include <mbgl/shader/line_pattern_shader.hpp>
#include <mbgl/shader/line_pattern.vertex.hpp>
#include <mbgl/shader/line_pattern.fragment.hpp>
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

View File

@@ -1,20 +0,0 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/shader/line_uniforms.hpp>
#include <mbgl/shader/line_attributes.hpp>
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

View File

@@ -1,16 +0,0 @@
#include <mbgl/shader/line_sdf_shader.hpp>
#include <mbgl/shader/line_sdf.vertex.hpp>
#include <mbgl/shader/line_sdf.fragment.hpp>
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

View File

@@ -1,21 +0,0 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/shader/line_uniforms.hpp>
#include <mbgl/shader/line_attributes.hpp>
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

View File

@@ -1,16 +0,0 @@
#include <mbgl/shader/line_shader.hpp>
#include <mbgl/shader/line.vertex.hpp>
#include <mbgl/shader/line.fragment.hpp>
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

View File

@@ -1,21 +0,0 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/shader/line_uniforms.hpp>
#include <mbgl/shader/line_attributes.hpp>
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

View File

@@ -1,109 +0,0 @@
#pragma once
#include <mbgl/shader/uniforms.hpp>
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

View File

@@ -1,29 +0,0 @@
#pragma once
#include <mbgl/shader/attributes.hpp>
#include <mbgl/util/geometry.hpp>
namespace mbgl {
struct RasterAttributes : gl::Attributes<
attributes::a_pos,
attributes::a_texture_pos>
{
static Vertex vertex(Point<int16_t> p, Point<uint16_t> 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

View File

@@ -1,16 +0,0 @@
#include <mbgl/shader/raster_shader.hpp>
#include <mbgl/shader/raster.vertex.hpp>
#include <mbgl/shader/raster.fragment.hpp>
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

View File

@@ -1,20 +0,0 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/shader/raster_uniforms.hpp>
#include <mbgl/shader/raster_attributes.hpp>
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

View File

@@ -1,37 +0,0 @@
#pragma once
#include <mbgl/shader/uniforms.hpp>
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

View File

@@ -1,53 +0,0 @@
#pragma once
#include <mbgl/shader/circle_shader.hpp>
#include <mbgl/shader/fill_shader.hpp>
#include <mbgl/shader/fill_pattern_shader.hpp>
#include <mbgl/shader/fill_outline_shader.hpp>
#include <mbgl/shader/fill_outline_pattern_shader.hpp>
#include <mbgl/shader/line_shader.hpp>
#include <mbgl/shader/line_sdf_shader.hpp>
#include <mbgl/shader/line_pattern_shader.hpp>
#include <mbgl/shader/raster_shader.hpp>
#include <mbgl/shader/symbol_icon_shader.hpp>
#include <mbgl/shader/symbol_sdf_shader.hpp>
#include <mbgl/shader/collision_box_shader.hpp>
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

View File

@@ -1,50 +0,0 @@
#pragma once
#include <mbgl/shader/attributes.hpp>
#include <mbgl/util/geometry.hpp>
#include <cmath>
namespace mbgl {
struct SymbolAttributes : gl::Attributes<
attributes::a_pos,
attributes::a_offset,
attributes::a_texture_pos,
attributes::a_data<4>>
{
static Vertex vertex(Point<float> a,
Point<float> o,
uint16_t tx,
uint16_t ty,
float minzoom,
float maxzoom,
float labelminzoom,
uint8_t labelangle) {
return Vertex {
{
static_cast<int16_t>(a.x),
static_cast<int16_t>(a.y)
},
{
static_cast<int16_t>(::round(o.x * 64)), // use 1/64 pixels for placement
static_cast<int16_t>(::round(o.y * 64))
},
{
static_cast<uint16_t>(tx / 4),
static_cast<uint16_t>(ty / 4)
},
{
static_cast<uint8_t>(labelminzoom * 10), // 1/10 zoom levels: z16 == 160
static_cast<uint8_t>(labelangle),
static_cast<uint8_t>(minzoom * 10),
static_cast<uint8_t>(::fmin(maxzoom, 25) * 10)
}
};
}
};
using SymbolVertex = SymbolAttributes::Vertex;
static_assert(sizeof(SymbolVertex) == 16, "expected SymbolVertex size");
} // namespace mbgl

View File

@@ -1,16 +0,0 @@
#include <mbgl/shader/symbol_icon_shader.hpp>
#include <mbgl/shader/symbol_icon.vertex.hpp>
#include <mbgl/shader/symbol_icon.fragment.hpp>
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

View File

@@ -1,20 +0,0 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/shader/symbol_uniforms.hpp>
#include <mbgl/shader/symbol_attributes.hpp>
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

View File

@@ -1,16 +0,0 @@
#include <mbgl/shader/symbol_sdf_shader.hpp>
#include <mbgl/shader/symbol_sdf.vertex.hpp>
#include <mbgl/shader/symbol_sdf.fragment.hpp>
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

View File

@@ -1,20 +0,0 @@
#pragma once
#include <mbgl/gl/shader.hpp>
#include <mbgl/shader/symbol_uniforms.hpp>
#include <mbgl/shader/symbol_attributes.hpp>
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

View File

@@ -1,77 +0,0 @@
#pragma once
#include <mbgl/shader/uniforms.hpp>
#include <mbgl/util/size.hpp>
#include <array>
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<float, 2>& 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<float, 2>& pixelsToGLUnits,
const RenderTile&,
const TransformState&,
float pixelRatio);
static Values foregroundValues(const style::SymbolPropertyValues&,
const Size& texsize,
const std::array<float, 2>& pixelsToGLUnits,
const RenderTile&,
const TransformState&,
float pixelRatio);
};
} // namespace mbgl

View File

@@ -7,6 +7,8 @@
#include <memory>
using namespace mbgl;
namespace {
static bool getFlag = false;
@@ -27,7 +29,7 @@ TEST(GLObject, PreserveState) {
getFlag = false;
setFlag = false;
auto object = std::make_unique<mbgl::gl::PreserveState<MockGLObject>>();
auto object = std::make_unique<gl::PreserveState<MockGLObject>>();
EXPECT_TRUE(getFlag);
EXPECT_FALSE(setFlag);
@@ -40,7 +42,7 @@ TEST(GLObject, PreserveState) {
TEST(GLObject, Value) {
setFlag = false;
auto object = std::make_unique<mbgl::gl::State<MockGLObject>>();
auto object = std::make_unique<gl::State<MockGLObject>>();
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());
HeadlessBackend backend;
OffscreenView view(backend.getContext());
mbgl::gl::Context context;
gl::Context context;
EXPECT_TRUE(context.empty());
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();
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());