[core] Introduce gl::Program template
This commit is contained in:
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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
37
src/mbgl/gl/program.hpp
Normal 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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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,
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -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_) {
|
||||
|
||||
@@ -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);
|
||||
|
||||
7
src/mbgl/programs/circle_program.cpp
Normal file
7
src/mbgl/programs/circle_program.cpp
Normal file
@@ -0,0 +1,7 @@
|
||||
#include <mbgl/programs/circle_program.hpp>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
static_assert(sizeof(CircleProgram::Vertex) == 4, "expected CircleVertex size");
|
||||
|
||||
} // namespace mbgl
|
||||
52
src/mbgl/programs/circle_program.hpp
Normal file
52
src/mbgl/programs/circle_program.hpp
Normal 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
|
||||
7
src/mbgl/programs/collision_box_program.cpp
Normal file
7
src/mbgl/programs/collision_box_program.cpp
Normal 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
|
||||
53
src/mbgl/programs/collision_box_program.hpp
Normal file
53
src/mbgl/programs/collision_box_program.hpp
Normal 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
|
||||
@@ -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,
|
||||
@@ -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
|
||||
@@ -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,
|
||||
184
src/mbgl/programs/line_program.hpp
Normal file
184
src/mbgl/programs/line_program.hpp
Normal 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
|
||||
31
src/mbgl/programs/program.hpp
Normal file
31
src/mbgl/programs/program.hpp
Normal 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
|
||||
46
src/mbgl/programs/programs.hpp
Normal file
46
src/mbgl/programs/programs.hpp
Normal 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
|
||||
7
src/mbgl/programs/raster_program.cpp
Normal file
7
src/mbgl/programs/raster_program.cpp
Normal file
@@ -0,0 +1,7 @@
|
||||
#include <mbgl/programs/raster_program.hpp>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
static_assert(sizeof(RasterProgram::Vertex) == 8, "expected RasterVertex size");
|
||||
|
||||
} // namespace mbgl
|
||||
65
src/mbgl/programs/raster_program.hpp
Normal file
65
src/mbgl/programs/raster_program.hpp
Normal 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
|
||||
@@ -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,
|
||||
134
src/mbgl/programs/symbol_program.hpp
Normal file
134
src/mbgl/programs/symbol_program.hpp
Normal 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
|
||||
@@ -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());
|
||||
|
||||
@@ -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 {
|
||||
|
||||
|
||||
@@ -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>
|
||||
|
||||
|
||||
@@ -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 {
|
||||
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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>
|
||||
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -2,12 +2,12 @@
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
class Shaders;
|
||||
class Programs;
|
||||
class View;
|
||||
|
||||
class PaintParameters {
|
||||
public:
|
||||
Shaders& shaders;
|
||||
Programs& programs;
|
||||
View& view;
|
||||
};
|
||||
|
||||
|
||||
@@ -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
|
||||
};
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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 },
|
||||
|
||||
@@ -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) },
|
||||
|
||||
@@ -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 {} },
|
||||
|
||||
@@ -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 },
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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 },
|
||||
|
||||
@@ -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) },
|
||||
|
||||
@@ -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>
|
||||
|
||||
|
||||
@@ -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>
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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());
|
||||
|
||||
Reference in New Issue
Block a user