tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use CHECK_ERROR on every GL call

Browse Source
This commit is contained in:
Leith Bade
2014-12-10 21:32:11 +11:00
parent 392150dd48
commit 0808485453
36 changed files with 365 additions and 355 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
platform/default/glfw_view.cpp
View File

@@ -1,5 +1,6 @@
#include <mbgl/platform/default/glfw_view.hpp>
#include <mbgl/platform/gl.hpp>
#include <mbgl/platform/log.hpp>
GLFWView::GLFWView(bool fullscreen_) : fullscreen(fullscreen_) {
#ifdef NVIDIA
@@ -11,9 +12,16 @@ GLFWView::~GLFWView() {
glfwTerminate();
}
void glfwError(int error, const char *description) {
mbgl::Log::Error(mbgl::Event::OpenGL, "GLFW error (%i): %s", error, description);
assert(false);
}
void GLFWView::initialize(mbgl::Map *map_) {
View::initialize(map_);
glfwSetErrorCallback(glfwError);
if (!glfwInit()) {
fprintf(stderr, "Failed to initialize glfw\n");
exit(1);
@@ -65,7 +73,7 @@ void GLFWView::initialize(mbgl::Map *map_) {
glfwSetScrollCallback(window, scroll);
glfwSetKeyCallback(window, key);
const std::string extensions = (char *)glGetString(GL_EXTENSIONS);
const std::string extensions = (char *)CHECK_ERROR(glGetString(GL_EXTENSIONS));
{
using namespace mbgl;
@@ -345,9 +353,9 @@ void show_debug_image(std::string name, const char *data, size_t width, size_t h
glfwGetFramebufferSize(debug_window, &fb_width, &fb_height);
float scale = (float)fb_width / (float)width;
glPixelZoom(scale, -scale);
glRasterPos2f(-1.0f, 1.0f);
glDrawPixels(width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, data);
CHECK_ERROR(glPixelZoom(scale, -scale));
CHECK_ERROR(glRasterPos2f(-1.0f, 1.0f));
CHECK_ERROR(glDrawPixels(width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, data));
glfwSwapBuffers(debug_window);
glfwMakeContextCurrent(current_window);
@@ -377,13 +385,13 @@ void show_color_debug_image(std::string name, const char *data, size_t logical_w
float x_scale = (float)fb_width / (float)width;
float y_scale = (float)fb_height / (float)height;
glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT));
CHECK_ERROR(glEnable(GL_BLEND));
CHECK_ERROR(glBlendFunc(GL_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
glPixelZoom(x_scale, -y_scale);
glRasterPos2f(-1.0f, 1.0f);
glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
CHECK_ERROR(glPixelZoom(x_scale, -y_scale));
CHECK_ERROR(glRasterPos2f(-1.0f, 1.0f));
CHECK_ERROR(glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, data));
glfwSwapBuffers(debug_window);
glfwMakeContextCurrent(current_window);

38
platform/default/headless_view.cpp
View File

@@ -52,7 +52,7 @@ HeadlessView::HeadlessView(std::shared_ptr<HeadlessDisplay> display)
void HeadlessView::loadExtensions() {
make_active();
const std::string extensions = (char *)glGetString(GL_EXTENSIONS);
const std::string extensions = (char *)CHECK_ERROR(glGetString(GL_EXTENSIONS));
#ifdef MBGL_USE_CGL
if (extensions.find("GL_APPLE_vertex_array_object") != std::string::npos) {
@@ -204,23 +204,23 @@ void HeadlessView::resize(uint16_t width, uint16_t height, float pixelRatio) {
make_active();
// Create depth/stencil buffer
glGenRenderbuffersEXT(1, &fboDepthStencil);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboDepthStencil);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, w, h);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
CHECK_ERROR(glGenRenderbuffersEXT(1, &fboDepthStencil));
CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboDepthStencil));
CHECK_ERROR(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, w, h));
CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0));
glGenRenderbuffersEXT(1, &fboColor);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboColor);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, w, h);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
CHECK_ERROR(glGenRenderbuffersEXT(1, &fboColor));
CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, fboColor));
CHECK_ERROR(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA8, w, h));
CHECK_ERROR(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0));
glGenFramebuffersEXT(1, &fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
CHECK_ERROR(glGenFramebuffersEXT(1, &fbo));
CHECK_ERROR(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo));
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, fboColor);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, fboDepthStencil);
CHECK_ERROR(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, fboColor));
CHECK_ERROR(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, fboDepthStencil));
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
GLenum status = CHECK_ERROR(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT));
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
std::stringstream error("Couldn't create framebuffer: ");
@@ -247,7 +247,7 @@ std::unique_ptr<uint32_t[]> HeadlessView::readPixels() {
auto pixels = util::make_unique<uint32_t[]>(w * h);
make_active();
glReadPixels(0, 0, width_, height_, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get());
CHECK_ERROR(glReadPixels(0, 0, width_, height_, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get()));
make_inactive();
const int stride = w * 4;
@@ -265,20 +265,20 @@ std::unique_ptr<uint32_t[]> HeadlessView::readPixels() {
void HeadlessView::clear_buffers() {
make_active();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
CHECK_ERROR(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
if (fbo) {
glDeleteFramebuffersEXT(1, &fbo);
CHECK_ERROR(glDeleteFramebuffersEXT(1, &fbo));
fbo = 0;
}
if (fboColor) {
glDeleteTextures(1, &fboColor);
CHECK_ERROR(glDeleteTextures(1, &fboColor));
fboColor = 0;
}
if (fboDepthStencil) {
glDeleteRenderbuffersEXT(1, &fboDepthStencil);
CHECK_ERROR(glDeleteRenderbuffersEXT(1, &fboDepthStencil));
fboDepthStencil = 0;
}

8
src/mbgl/geometry/buffer.hpp
View File

@@ -21,7 +21,7 @@ public:
~Buffer() {
cleanup();
if (buffer != 0) {
glDeleteBuffers(1, &buffer);
CHECK_ERROR(glDeleteBuffers(1, &buffer));
buffer = 0;
}
}
@@ -39,16 +39,16 @@ public:
// Transfers this buffer to the GPU and binds the buffer to the GL context.
void bind(bool force = false) {
if (buffer == 0) {
glGenBuffers(1, &buffer);
CHECK_ERROR(glGenBuffers(1, &buffer));
force = true;
}
glBindBuffer(bufferType, buffer);
CHECK_ERROR(glBindBuffer(bufferType, buffer));
if (force) {
if (array == nullptr) {
throw std::runtime_error("Buffer was already deleted or doesn't contain elements");
}
glBufferData(bufferType, pos, array, GL_STATIC_DRAW);
CHECK_ERROR(glBufferData(bufferType, pos, array, GL_STATIC_DRAW));
if (!retainAfterUpload) {
cleanup();
}

18
src/mbgl/geometry/glyph_atlas.cpp
View File

@@ -142,22 +142,22 @@ void GlyphAtlas::removeGlyphs(uint64_t tile_id) {
void GlyphAtlas::bind() {
if (!texture) {
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
CHECK_ERROR(glGenTextures(1, &texture));
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
#ifndef GL_ES_VERSION_2_0
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
#endif
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
} else {
glBindTexture(GL_TEXTURE_2D, texture);
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
}
if (dirty) {
std::lock_guard<std::mutex> lock(mtx);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, data.get());
CHECK_ERROR(glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, data.get()));
dirty = false;
#if defined(DEBUG)

18
src/mbgl/geometry/sprite_atlas.cpp
View File

@@ -199,22 +199,22 @@ void SpriteAtlas::setSprite(util::ptr<Sprite> sprite_) {
void SpriteAtlas::bind(bool linear) {
bool first = false;
if (!texture) {
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
CHECK_ERROR(glGenTextures(1, &texture));
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
#ifndef GL_ES_VERSION_2_0
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
#endif
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
first = true;
} else {
glBindTexture(GL_TEXTURE_2D, texture);
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
}
GLuint filter_val = linear ? GL_LINEAR : GL_NEAREST;
if (filter_val != filter) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter_val);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter_val);
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter_val));
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter_val));
filter = filter_val;
}
@@ -255,7 +255,7 @@ void SpriteAtlas::bind(bool linear) {
SpriteAtlas::~SpriteAtlas() {
std::lock_guard<std::recursive_mutex> lock(mtx);
glDeleteTextures(1, &texture);
CHECK_ERROR(glDeleteTextures(1, &texture));
texture = 0;
::operator delete(data), data = nullptr;
}

6
src/mbgl/geometry/vao.cpp
View File

@@ -8,7 +8,7 @@ VertexArrayObject::~VertexArrayObject() {
if (!gl::DeleteVertexArrays) return;
if (vao) {
gl::DeleteVertexArrays(1, &vao);
CHECK_ERROR(gl::DeleteVertexArrays(1, &vao));
}
}
@@ -23,9 +23,9 @@ void VertexArrayObject::bindVertexArrayObject() {
}
if (!vao) {
gl::GenVertexArrays(1, &vao);
CHECK_ERROR(gl::GenVertexArrays(1, &vao));
}
gl::BindVertexArray(vao);
CHECK_ERROR(gl::BindVertexArray(vao));
}
void VertexArrayObject::verifyBinding(Shader &shader, GLuint vertexBuffer, GLuint elementsBuffer,

4
src/mbgl/renderer/debug_bucket.cpp
View File

@@ -23,10 +23,10 @@ bool DebugBucket::hasData() const {
void DebugBucket::drawLines(PlainShader& shader) {
array.bind(shader, fontBuffer, BUFFER_OFFSET(0));
glDrawArrays(GL_LINES, 0, (GLsizei)(fontBuffer.index()));
CHECK_ERROR(glDrawArrays(GL_LINES, 0, (GLsizei)(fontBuffer.index())));
}
void DebugBucket::drawPoints(PlainShader& shader) {
array.bind(shader, fontBuffer, BUFFER_OFFSET(0));
glDrawArrays(GL_POINTS, 0, (GLsizei)(fontBuffer.index()));
CHECK_ERROR(glDrawArrays(GL_POINTS, 0, (GLsizei)(fontBuffer.index())));
}

6
src/mbgl/renderer/fill_bucket.cpp
View File

@@ -217,7 +217,7 @@ void FillBucket::drawElements(PlainShader& shader) {
char *elements_index = BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer.itemSize);
for (triangle_group_type& group : triangleGroups) {
group.array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
vertex_index += group.vertex_length * vertexBuffer.itemSize;
elements_index += group.elements_length * triangleElementsBuffer.itemSize;
}
@@ -228,7 +228,7 @@ void FillBucket::drawElements(PatternShader& shader) {
char *elements_index = BUFFER_OFFSET(triangle_elements_start * triangleElementsBuffer.itemSize);
for (triangle_group_type& group : triangleGroups) {
group.array[1].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
vertex_index += group.vertex_length * vertexBuffer.itemSize;
elements_index += group.elements_length * triangleElementsBuffer.itemSize;
}
@@ -239,7 +239,7 @@ void FillBucket::drawVertices(OutlineShader& shader) {
char *elements_index = BUFFER_OFFSET(line_elements_start * lineElementsBuffer.itemSize);
for (line_group_type& group : lineGroups) {
group.array[0].bind(shader, vertexBuffer, lineElementsBuffer, vertex_index);
glDrawElements(GL_LINES, group.elements_length * 2, GL_UNSIGNED_SHORT, elements_index);
CHECK_ERROR(glDrawElements(GL_LINES, group.elements_length * 2, GL_UNSIGNED_SHORT, elements_index));
vertex_index += group.vertex_length * vertexBuffer.itemSize;
elements_index += group.elements_length * lineElementsBuffer.itemSize;
}

6
src/mbgl/renderer/line_bucket.cpp
View File

@@ -368,7 +368,7 @@ void LineBucket::drawLines(LineShader& shader) {
continue;
}
group.array[0].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
vertex_index += group.vertex_length * vertexBuffer.itemSize;
elements_index += group.elements_length * triangleElementsBuffer.itemSize;
}
@@ -382,7 +382,7 @@ void LineBucket::drawLinePatterns(LinepatternShader& shader) {
continue;
}
group.array[1].bind(shader, vertexBuffer, triangleElementsBuffer, vertex_index);
glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
vertex_index += group.vertex_length * vertexBuffer.itemSize;
elements_index += group.elements_length * triangleElementsBuffer.itemSize;
}
@@ -396,7 +396,7 @@ void LineBucket::drawPoints(LinejoinShader& shader) {
continue;
}
group.array[0].bind(shader, vertexBuffer, pointElementsBuffer, vertex_index);
glDrawElements(GL_POINTS, group.elements_length, GL_UNSIGNED_SHORT, elements_index);
CHECK_ERROR(glDrawElements(GL_POINTS, group.elements_length, GL_UNSIGNED_SHORT, elements_index));
vertex_index += group.vertex_length * vertexBuffer.itemSize;
elements_index += group.elements_length * pointElementsBuffer.itemSize;
}

48
src/mbgl/renderer/painter.cpp
View File

@@ -45,13 +45,13 @@ void Painter::setup() {
// Enable GL debugging
if ((gl::DebugMessageControl != nullptr) && (gl::DebugMessageCallback != nullptr)) {
// This will enable all messages including performance hints
gl::DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
CHECK_ERROR(gl::DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE));
// This will only enable high and medium severity messages
//gl::DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_HIGH, 0, nullptr, GL_TRUE);
//gl::DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0, nullptr, GL_TRUE);
gl::DebugMessageCallback(gl::debug_callback, nullptr);
CHECK_ERROR(gl::DebugMessageCallback(gl::debug_callback, nullptr));
}
setupShaders();
@@ -74,17 +74,17 @@ void Painter::setup() {
// We are blending new pixels on top of old pixels. Since we have depth testing
// and are drawing opaque fragments first front-to-back, then translucent
// fragments back-to-front, this shades the fewest fragments possible.
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
CHECK_ERROR(glEnable(GL_BLEND));
CHECK_ERROR(glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
// Set clear values
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glClearStencil(0x0);
CHECK_ERROR(glClearColor(0.0f, 0.0f, 0.0f, 0.0f));
CHECK_ERROR(glClearDepth(1.0f));
CHECK_ERROR(glClearStencil(0x0));
// Stencil test
glEnable(GL_STENCIL_TEST);
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
CHECK_ERROR(glEnable(GL_STENCIL_TEST));
CHECK_ERROR(glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE));
}
void Painter::setupShaders() {
@@ -125,7 +125,7 @@ void Painter::resize() {
if (gl_viewport != state.getFramebufferDimensions()) {
gl_viewport = state.getFramebufferDimensions();
assert(gl_viewport[0] > 0 && gl_viewport[1] > 0);
glViewport(0, 0, gl_viewport[0], gl_viewport[1]);
CHECK_ERROR(glViewport(0, 0, gl_viewport[0], gl_viewport[1]));
}
}
@@ -135,28 +135,28 @@ void Painter::setDebug(bool enabled) {
void Painter::useProgram(uint32_t program) {
if (gl_program != program) {
glUseProgram(program);
CHECK_ERROR(glUseProgram(program));
gl_program = program;
}
}
void Painter::lineWidth(float line_width) {
if (gl_lineWidth != line_width) {
glLineWidth(line_width);
CHECK_ERROR(glLineWidth(line_width));
gl_lineWidth = line_width;
}
}
void Painter::depthMask(bool value) {
if (gl_depthMask != value) {
glDepthMask(value ? GL_TRUE : GL_FALSE);
CHECK_ERROR(glDepthMask(value ? GL_TRUE : GL_FALSE));
gl_depthMask = value;
}
}
void Painter::depthRange(const float near, const float far) {
if (gl_depthRange[0] != near || gl_depthRange[1] != far) {
glDepthRange(near, far);
CHECK_ERROR(glDepthRange(near, far));
gl_depthRange = {{ near, far }};
}
}
@@ -179,17 +179,17 @@ void Painter::changeMatrix() {
void Painter::clear() {
gl::group group("clear");
glStencilMask(0xFF);
CHECK_ERROR(glStencilMask(0xFF));
depthMask(true);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
CHECK_ERROR(glClearColor(0, 0, 0, 0));
CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
}
void Painter::setOpaque() {
if (pass != RenderPass::Opaque) {
pass = RenderPass::Opaque;
glDisable(GL_BLEND);
CHECK_ERROR(glDisable(GL_BLEND));
depthMask(true);
}
}
@@ -197,7 +197,7 @@ void Painter::setOpaque() {
void Painter::setTranslucent() {
if (pass != RenderPass::Translucent) {
pass = RenderPass::Translucent;
glEnable(GL_BLEND);
CHECK_ERROR(glEnable(GL_BLEND));
depthMask(false);
}
}
@@ -209,7 +209,7 @@ void Painter::setStrata(float value) {
void Painter::prepareTile(const Tile& tile) {
const GLint ref = (GLint)tile.clip.reference.to_ulong();
const GLuint mask = (GLuint)tile.clip.mask.to_ulong();
glStencilFunc(GL_EQUAL, ref, mask);
CHECK_ERROR(glStencilFunc(GL_EQUAL, ref, mask));
}
void Painter::render(const Style& style, const std::set<util::ptr<StyleSource>>& sources,
@@ -244,7 +244,7 @@ void Painter::render(const Style& style, const std::set<util::ptr<StyleSource>>&
source->source->finishRender(*this);
}
glFlush();
CHECK_ERROR(glFlush());
}
void Painter::renderLayers(util::ptr<StyleLayerGroup> group) {
@@ -427,10 +427,10 @@ void Painter::renderBackground(util::ptr<StyleLayer> layer_desc) {
backgroundArray.bind(*plainShader, backgroundBuffer, BUFFER_OFFSET(0));
}
glDisable(GL_STENCIL_TEST);
CHECK_ERROR(glDisable(GL_STENCIL_TEST));
depthRange(strata + strata_epsilon, 1.0f);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glEnable(GL_STENCIL_TEST);
CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
CHECK_ERROR(glEnable(GL_STENCIL_TEST));
}
mat4 Painter::translatedMatrix(const mat4& matrix, const std::array<float, 2> &translation, const Tile::ID &id, TranslateAnchorType anchor) {

16
src/mbgl/renderer/painter_clipping.cpp
View File

@@ -10,9 +10,9 @@ void Painter::drawClippingMasks(const std::set<util::ptr<StyleSource>> &sources)
gl::group group("clipping masks");
useProgram(plainShader->program);
glDisable(GL_DEPTH_TEST);
CHECK_ERROR(glDisable(GL_DEPTH_TEST));
depthMask(false);
glColorMask(false, false, false, false);
CHECK_ERROR(glColorMask(false, false, false, false));
depthRange(1.0f, 1.0f);
coveringPlainArray.bind(*plainShader, tileStencilBuffer, BUFFER_OFFSET(0));
@@ -21,10 +21,10 @@ void Painter::drawClippingMasks(const std::set<util::ptr<StyleSource>> &sources)
source->source->drawClippingMasks(*this);
}
glEnable(GL_DEPTH_TEST);
glColorMask(true, true, true, true);
CHECK_ERROR(glEnable(GL_DEPTH_TEST));
CHECK_ERROR(glColorMask(true, true, true, true));
depthMask(true);
glStencilMask(0x0);
CHECK_ERROR(glStencilMask(0x0));
}
void Painter::drawClippingMask(const mat4& matrix, const ClipID &clip) {
@@ -32,8 +32,8 @@ void Painter::drawClippingMask(const mat4& matrix, const ClipID &clip) {
const GLint ref = (GLint)(clip.reference.to_ulong());
const GLuint mask = (GLuint)(clip.mask.to_ulong());
glStencilFunc(GL_ALWAYS, ref, mask);
glStencilMask(mask);
CHECK_ERROR(glStencilFunc(GL_ALWAYS, ref, mask));
CHECK_ERROR(glStencilMask(mask));
glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index());
CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index()));
}

26
src/mbgl/renderer/painter_debug.cpp
View File

@@ -18,7 +18,7 @@ void Painter::renderTileDebug(const Tile& tile) {
void Painter::renderDebugText(DebugBucket& bucket, const mat4 &matrix) {
gl::group group("debug text");
glDisable(GL_DEPTH_TEST);
CHECK_ERROR(glDisable(GL_DEPTH_TEST));
useProgram(plainShader->program);
plainShader->u_matrix = matrix;
@@ -30,7 +30,7 @@ void Painter::renderDebugText(DebugBucket& bucket, const mat4 &matrix) {
#ifndef GL_ES_VERSION_2_0
// Draw line "end caps"
glPointSize(2);
CHECK_ERROR(glPointSize(2));
bucket.drawPoints(*plainShader);
#endif
@@ -39,7 +39,7 @@ void Painter::renderDebugText(DebugBucket& bucket, const mat4 &matrix) {
lineWidth(2.0f * state.getPixelRatio());
bucket.drawLines(*plainShader);
glEnable(GL_DEPTH_TEST);
CHECK_ERROR(glEnable(GL_DEPTH_TEST));
}
void Painter::renderDebugFrame(const mat4 &matrix) {
@@ -48,7 +48,7 @@ void Painter::renderDebugFrame(const mat4 &matrix) {
// Disable depth test and don't count this towards the depth buffer,
// but *don't* disable stencil test, as we want to clip the red tile border
// to the tile viewport.
glDisable(GL_DEPTH_TEST);
CHECK_ERROR(glDisable(GL_DEPTH_TEST));
useProgram(plainShader->program);
plainShader->u_matrix = matrix;
@@ -57,9 +57,9 @@ void Painter::renderDebugFrame(const mat4 &matrix) {
tileBorderArray.bind(*plainShader, tileBorderBuffer, BUFFER_OFFSET(0));
plainShader->u_color = {{ 1.0f, 0.0f, 0.0f, 1.0f }};
lineWidth(4.0f * state.getPixelRatio());
glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)tileBorderBuffer.index());
CHECK_ERROR(glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)tileBorderBuffer.index()));
glEnable(GL_DEPTH_TEST);
CHECK_ERROR(glEnable(GL_DEPTH_TEST));
}
void Painter::renderDebugText(const std::vector<std::string> &strings) {
@@ -69,8 +69,8 @@ void Painter::renderDebugText(const std::vector<std::string> &strings) {
gl::group group("debug text");
glDisable(GL_DEPTH_TEST);
glStencilFunc(GL_ALWAYS, 0xFF, 0xFF);
CHECK_ERROR(glDisable(GL_DEPTH_TEST));
CHECK_ERROR(glStencilFunc(GL_ALWAYS, 0xFF, 0xFF));
useProgram(plainShader->program);
plainShader->u_matrix = nativeMatrix;
@@ -88,15 +88,15 @@ void Painter::renderDebugText(const std::vector<std::string> &strings) {
debugFontArray.bind(*plainShader, debugFontBuffer, BUFFER_OFFSET(0));
plainShader->u_color = {{ 1.0f, 1.0f, 1.0f, 1.0f }};
lineWidth(4.0f * state.getPixelRatio());
glDrawArrays(GL_LINES, 0, (GLsizei)debugFontBuffer.index());
CHECK_ERROR(glDrawArrays(GL_LINES, 0, (GLsizei)debugFontBuffer.index()));
#ifndef GL_ES_VERSION_2_0
glPointSize(2);
glDrawArrays(GL_POINTS, 0, (GLsizei)debugFontBuffer.index());
CHECK_ERROR(glPointSize(2));
CHECK_ERROR(glDrawArrays(GL_POINTS, 0, (GLsizei)debugFontBuffer.index()));
#endif
plainShader->u_color = {{ 0.0f, 0.0f, 0.0f, 1.0f }};
lineWidth(2.0f * state.getPixelRatio());
glDrawArrays(GL_LINES, 0, (GLsizei)debugFontBuffer.index());
CHECK_ERROR(glDrawArrays(GL_LINES, 0, (GLsizei)debugFontBuffer.index()));
}
glEnable(GL_DEPTH_TEST);
CHECK_ERROR(glEnable(GL_DEPTH_TEST));
}

2
src/mbgl/renderer/painter_fill.cpp
View File

@@ -76,7 +76,7 @@ void Painter::renderFill(FillBucket& bucket, util::ptr<StyleLayer> layer_desc, c
patternShader->u_mix = mix;
patternShader->u_patternmatrix = patternMatrix;
glActiveTexture(GL_TEXTURE0);
CHECK_ERROR(glActiveTexture(GL_TEXTURE0));
spriteAtlas.bind(true);
// Draw the actual triangles into the color & stencil buffer.

4
src/mbgl/renderer/painter_line.cpp
View File

@@ -55,7 +55,7 @@ void Painter::renderLine(LineBucket& bucket, util::ptr<StyleLayer> layer_desc, c
#if defined(GL_ES_VERSION_2_0)
linejoinShader->u_size = pointSize;
#else
glPointSize(pointSize);
CHECK_ERROR(glPointSize(pointSize));
#endif
bucket.drawPoints(*linejoinShader);
}
@@ -80,7 +80,7 @@ void Painter::renderLine(LineBucket& bucket, util::ptr<StyleLayer> layer_desc, c
linepatternShader->u_fade = fade;
spriteAtlas.bind(true);
glDepthRange(strata + strata_epsilon, 1.0f); // may or may not matter
CHECK_ERROR(glDepthRange(strata + strata_epsilon, 1.0f)); // may or may not matter
bucket.drawLinePatterns(*linepatternShader);

16
src/mbgl/renderer/painter_prerender.cpp
View File

@@ -6,18 +6,18 @@
using namespace mbgl;
void Painter::preparePrerender(RasterBucket &bucket) {
glDisable(GL_DEPTH_TEST);
glDisable(GL_STENCIL_TEST);
CHECK_ERROR(glDisable(GL_DEPTH_TEST));
CHECK_ERROR(glDisable(GL_STENCIL_TEST));
// Render the actual tile.
#if GL_EXT_discard_framebuffer
const GLenum discards[] = {GL_COLOR_ATTACHMENT0};
glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards);
CHECK_ERROR(glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards));
#endif
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
CHECK_ERROR(glClearColor(0.0, 0.0, 0.0, 0.0));
CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT));
glViewport(0, 0, bucket.properties.size, bucket.properties.size);
CHECK_ERROR(glViewport(0, 0, bucket.properties.size, bucket.properties.size));
}
void Painter::renderPrerenderedTexture(RasterBucket &bucket, const mat4 &matrix, const RasterProperties& properties) {
@@ -30,7 +30,7 @@ void Painter::renderPrerenderedTexture(RasterBucket &bucket, const mat4 &matrix,
depthRange(strata, 1.0f);
glActiveTexture(GL_TEXTURE0);
CHECK_ERROR(glActiveTexture(GL_TEXTURE0));
rasterShader->u_image = 0;
rasterShader->u_buffer = buffer;
rasterShader->u_opacity = properties.opacity;
@@ -41,5 +41,5 @@ void Painter::renderPrerenderedTexture(RasterBucket &bucket, const mat4 &matrix,
rasterShader->u_spin_weights = spinWeights(properties.hue_rotate);
bucket.texture.bindTexture();
coveringRasterArray.bind(*rasterShader, tileStencilBuffer, BUFFER_OFFSET(0));
glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index());
CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index()));
}

6
src/mbgl/renderer/painter_raster.cpp
View File

@@ -44,10 +44,10 @@ void Painter::renderRaster(RasterBucket& bucket, util::ptr<StyleLayer> layer_des
bucket.texture.unbindFramebuffer();
glEnable(GL_DEPTH_TEST);
glEnable(GL_STENCIL_TEST);
CHECK_ERROR(glEnable(GL_DEPTH_TEST));
CHECK_ERROR(glEnable(GL_STENCIL_TEST));
glViewport(0, 0, gl_viewport[0], gl_viewport[1]);
CHECK_ERROR(glViewport(0, 0, gl_viewport[0], gl_viewport[1]));
}

4
src/mbgl/renderer/painter_symbol.cpp
View File

@@ -118,7 +118,7 @@ void Painter::renderSymbol(SymbolBucket &bucket, util::ptr<StyleLayer> layer_des
const SymbolProperties &properties = layer_desc->getProperties<SymbolProperties>();
glDisable(GL_STENCIL_TEST);
CHECK_ERROR(glDisable(GL_STENCIL_TEST));
if (bucket.hasIconData()) {
bool sdf = bucket.sdfIcons;
@@ -204,5 +204,5 @@ void Painter::renderSymbol(SymbolBucket &bucket, util::ptr<StyleLayer> layer_des
&SymbolBucket::drawGlyphs);
}
glEnable(GL_STENCIL_TEST);
CHECK_ERROR(glEnable(GL_STENCIL_TEST));
}

96
src/mbgl/renderer/prerendered_texture.cpp
View File

@@ -11,12 +11,12 @@ PrerenderedTexture::PrerenderedTexture(const StyleBucketRaster &properties_)
PrerenderedTexture::~PrerenderedTexture() {
if (texture != 0) {
glDeleteTextures(1, &texture);
CHECK_ERROR(glDeleteTextures(1, &texture));
texture = 0;
}
if (fbo != 0) {
glDeleteFramebuffers(1, &fbo);
CHECK_ERROR(glDeleteFramebuffers(1, &fbo));
fbo = 0;
}
}
@@ -28,50 +28,50 @@ void PrerenderedTexture::bindTexture() {
unbindFramebuffer();
}
glBindTexture(GL_TEXTURE_2D, texture);
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
}
void PrerenderedTexture::bindFramebuffer() {
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &previous_fbo);
CHECK_ERROR(glGetIntegerv(GL_FRAMEBUFFER_BINDING, &previous_fbo));
if (texture == 0) {
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
CHECK_ERROR(glGenTextures(1, &texture));
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
#ifndef GL_ES_VERSION_2_0
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
#endif
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
CHECK_ERROR(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0));
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, 0));
}
if (fbo_depth_stencil == 0) {
// Create depth/stencil buffer
glGenRenderbuffers(1, &fbo_depth_stencil);
glBindRenderbuffer(GL_RENDERBUFFER, fbo_depth_stencil);
CHECK_ERROR(glGenRenderbuffers(1, &fbo_depth_stencil));
CHECK_ERROR(glBindRenderbuffer(GL_RENDERBUFFER, fbo_depth_stencil));
#ifdef GL_ES_VERSION_2_0
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, properties.size, properties.size);
CHECK_ERROR(glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, properties.size, properties.size));
#else
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, properties.size, properties.size);
CHECK_ERROR(glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, properties.size, properties.size));
#endif
glBindRenderbuffer(GL_RENDERBUFFER, 0);
CHECK_ERROR(glBindRenderbuffer(GL_RENDERBUFFER, 0));
}
if (fbo == 0) {
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
CHECK_ERROR(glGenFramebuffers(1, &fbo));
CHECK_ERROR(glBindFramebuffer(GL_FRAMEBUFFER, fbo));
CHECK_ERROR(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0));
#ifdef GL_ES_VERSION_2_0
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fbo_depth_stencil);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, fbo_depth_stencil);
CHECK_ERROR(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fbo_depth_stencil));
CHECK_ERROR(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, fbo_depth_stencil));
#else
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, fbo_depth_stencil);
CHECK_ERROR(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, fbo_depth_stencil));
#endif
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
GLenum status = CHECK_ERROR(glCheckFramebufferStatus(GL_FRAMEBUFFER));
if (status != GL_FRAMEBUFFER_COMPLETE) {
fprintf(stderr, "Couldn't create framebuffer: ");
switch (status) {
@@ -88,15 +88,15 @@ void PrerenderedTexture::bindFramebuffer() {
return;
}
} else {
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
CHECK_ERROR(glBindFramebuffer(GL_FRAMEBUFFER, fbo));
}
}
void PrerenderedTexture::unbindFramebuffer() {
glBindFramebuffer(GL_FRAMEBUFFER, previous_fbo);
CHECK_ERROR(glBindFramebuffer(GL_FRAMEBUFFER, previous_fbo));
if (fbo != 0) {
glDeleteFramebuffers(1, &fbo);
CHECK_ERROR(glDeleteFramebuffers(1, &fbo));
fbo = 0;
}
}
@@ -106,49 +106,49 @@ void PrerenderedTexture::blur(Painter& painter, uint16_t passes) {
// Create a secondary texture
GLuint secondary_texture;
glGenTextures(1, &secondary_texture);
glBindTexture(GL_TEXTURE_2D, secondary_texture);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
CHECK_ERROR(glGenTextures(1, &secondary_texture));
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, secondary_texture));
CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
CHECK_ERROR(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
CHECK_ERROR(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0));
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, 0));
painter.useProgram(painter.gaussianShader->program);
painter.gaussianShader->u_matrix = painter.flipMatrix;
painter.gaussianShader->u_image = 0;
glActiveTexture(GL_TEXTURE0);
CHECK_ERROR(glActiveTexture(GL_TEXTURE0));
for (int i = 0; i < passes; i++) {
// Render horizontal
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, secondary_texture, 0);
CHECK_ERROR(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, secondary_texture, 0));
#if GL_EXT_discard_framebuffer
const GLenum discards[] = { GL_COLOR_ATTACHMENT0 };
glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards);
CHECK_ERROR(glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards));
#endif
glClear(GL_COLOR_BUFFER_BIT);
CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT));
painter.gaussianShader->u_offset = {{ 1.0f / float(properties.size), 0 }};
glBindTexture(GL_TEXTURE_2D, original_texture);
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, original_texture));
painter.coveringGaussianArray.bind(*painter.gaussianShader, painter.tileStencilBuffer, BUFFER_OFFSET(0));
glDrawArrays(GL_TRIANGLES, 0, (GLsizei)painter.tileStencilBuffer.index());
CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)painter.tileStencilBuffer.index()));
// Render vertical
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, original_texture, 0);
CHECK_ERROR(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, original_texture, 0));
#if GL_EXT_discard_framebuffer
glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards);
CHECK_ERROR(glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards));
#endif
glClear(GL_COLOR_BUFFER_BIT);
CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT));
painter.gaussianShader->u_offset = {{ 0, 1.0f / float(properties.size) }};
glBindTexture(GL_TEXTURE_2D, secondary_texture);
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, secondary_texture));
painter.coveringGaussianArray.bind(*painter.gaussianShader, painter.tileStencilBuffer, BUFFER_OFFSET(0));
glDrawArrays(GL_TRIANGLES, 0, (GLsizei)painter.tileStencilBuffer.index());
CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)painter.tileStencilBuffer.index()));
}
glDeleteTextures(1, &secondary_texture);
CHECK_ERROR(glDeleteTextures(1, &secondary_texture));
}

4
src/mbgl/renderer/raster_bucket.cpp
View File

@@ -21,14 +21,14 @@ void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices
raster.bind(true);
shader.u_image = 0;
array.bind(shader, vertices, BUFFER_OFFSET(0));
glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index());
CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index()));
}
void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array, GLuint texture_) {
raster.bind(texture_);
shader.u_image = 0;
array.bind(shader, vertices, BUFFER_OFFSET(0));
glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index());
CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index()));
}
bool RasterBucket::hasData() const {

6
src/mbgl/renderer/symbol_bucket.cpp
View File

@@ -397,7 +397,7 @@ void SymbolBucket::drawGlyphs(SDFShader &shader) {
char *elements_index = BUFFER_OFFSET(0);
for (TextElementGroup &group : text.groups) {
group.array[0].bind(shader, text.vertices, text.triangles, vertex_index);
glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
vertex_index += group.vertex_length * text.vertices.itemSize;
elements_index += group.elements_length * text.triangles.itemSize;
}
@@ -408,7 +408,7 @@ void SymbolBucket::drawIcons(SDFShader &shader) {
char *elements_index = BUFFER_OFFSET(0);
for (IconElementGroup &group : icon.groups) {
group.array[0].bind(shader, icon.vertices, icon.triangles, vertex_index);
glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
vertex_index += group.vertex_length * icon.vertices.itemSize;
elements_index += group.elements_length * icon.triangles.itemSize;
}
@@ -419,7 +419,7 @@ void SymbolBucket::drawIcons(IconShader &shader) {
char *elements_index = BUFFER_OFFSET(0);
for (IconElementGroup &group : icon.groups) {
group.array[1].bind(shader, icon.vertices, icon.triangles, vertex_index);
glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index);
CHECK_ERROR(glDrawElements(GL_TRIANGLES, group.elements_length * 3, GL_UNSIGNED_SHORT, elements_index));
vertex_index += group.vertex_length * icon.vertices.itemSize;
elements_index += group.elements_length * icon.triangles.itemSize;
}

6
src/mbgl/shader/dot_shader.cpp
View File

@@ -17,10 +17,10 @@ DotShader::DotShader()
return;
}
a_pos = glGetAttribLocation(program, "a_pos");
a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
}
void DotShader::bind(char *offset) {
glEnableVertexAttribArray(a_pos);
glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset);
CHECK_ERROR(glEnableVertexAttribArray(a_pos));
CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset));
}

6
src/mbgl/shader/gaussian_shader.cpp
View File

@@ -19,10 +19,10 @@ GaussianShader::GaussianShader()
return;
}
a_pos = glGetAttribLocation(program, "a_pos");
a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
}
void GaussianShader::bind(char *offset) {
glEnableVertexAttribArray(a_pos);
glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset);
CHECK_ERROR(glEnableVertexAttribArray(a_pos));
CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
}

54
src/mbgl/shader/icon_shader.cpp
View File

@@ -17,44 +17,44 @@ IconShader::IconShader()
return;
}
a_pos = glGetAttribLocation(program, "a_pos");
a_offset = glGetAttribLocation(program, "a_offset");
a_tex = glGetAttribLocation(program, "a_tex");
a_angle = glGetAttribLocation(program, "a_angle");
a_minzoom = glGetAttribLocation(program, "a_minzoom");
a_maxzoom = glGetAttribLocation(program, "a_maxzoom");
a_rangeend = glGetAttribLocation(program, "a_rangeend");
a_rangestart = glGetAttribLocation(program, "a_rangestart");
a_labelminzoom = glGetAttribLocation(program, "a_labelminzoom");
a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
a_offset = CHECK_ERROR(glGetAttribLocation(program, "a_offset"));
a_tex = CHECK_ERROR(glGetAttribLocation(program, "a_tex"));
a_angle = CHECK_ERROR(glGetAttribLocation(program, "a_angle"));
a_minzoom = CHECK_ERROR(glGetAttribLocation(program, "a_minzoom"));
a_maxzoom = CHECK_ERROR(glGetAttribLocation(program, "a_maxzoom"));
a_rangeend = CHECK_ERROR(glGetAttribLocation(program, "a_rangeend"));
a_rangestart = CHECK_ERROR(glGetAttribLocation(program, "a_rangestart"));
a_labelminzoom = CHECK_ERROR(glGetAttribLocation(program, "a_labelminzoom"));
}
void IconShader::bind(char *offset) {
const int stride = 20;
glEnableVertexAttribArray(a_pos);
glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0);
CHECK_ERROR(glEnableVertexAttribArray(a_pos));
CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
glEnableVertexAttribArray(a_offset);
glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4);
CHECK_ERROR(glEnableVertexAttribArray(a_offset));
CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
glEnableVertexAttribArray(a_labelminzoom);
glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8);
CHECK_ERROR(glEnableVertexAttribArray(a_labelminzoom));
CHECK_ERROR(glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8));
glEnableVertexAttribArray(a_minzoom);
glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9);
CHECK_ERROR(glEnableVertexAttribArray(a_minzoom));
CHECK_ERROR(glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9));
glEnableVertexAttribArray(a_maxzoom);
glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10);
CHECK_ERROR(glEnableVertexAttribArray(a_maxzoom));
CHECK_ERROR(glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10));
glEnableVertexAttribArray(a_angle);
glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11);
CHECK_ERROR(glEnableVertexAttribArray(a_angle));
CHECK_ERROR(glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11));
glEnableVertexAttribArray(a_rangeend);
glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12);
CHECK_ERROR(glEnableVertexAttribArray(a_rangeend));
CHECK_ERROR(glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12));
glEnableVertexAttribArray(a_rangestart);
glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13);
CHECK_ERROR(glEnableVertexAttribArray(a_rangestart));
CHECK_ERROR(glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13));
glEnableVertexAttribArray(a_tex);
glVertexAttribPointer(a_tex, 2, GL_SHORT, false, stride, offset + 16);
CHECK_ERROR(glEnableVertexAttribArray(a_tex));
CHECK_ERROR(glVertexAttribPointer(a_tex, 2, GL_SHORT, false, stride, offset + 16));
}

18
src/mbgl/shader/line_shader.cpp
View File

@@ -17,18 +17,18 @@ LineShader::LineShader()
return;
}
a_pos = glGetAttribLocation(program, "a_pos");
a_extrude = glGetAttribLocation(program, "a_extrude");
a_linesofar = glGetAttribLocation(program, "a_linesofar");
a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
a_extrude = CHECK_ERROR(glGetAttribLocation(program, "a_extrude"));
a_linesofar = CHECK_ERROR(glGetAttribLocation(program, "a_linesofar"));
}
void LineShader::bind(char *offset) {
glEnableVertexAttribArray(a_pos);
glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0);
CHECK_ERROR(glEnableVertexAttribArray(a_pos));
CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
glEnableVertexAttribArray(a_extrude);
glVertexAttribPointer(a_extrude, 2, GL_BYTE, false, 8, offset + 4);
CHECK_ERROR(glEnableVertexAttribArray(a_extrude));
CHECK_ERROR(glVertexAttribPointer(a_extrude, 2, GL_BYTE, false, 8, offset + 4));
glEnableVertexAttribArray(a_linesofar);
glVertexAttribPointer(a_linesofar, 1, GL_SHORT, false, 8, offset + 6);
CHECK_ERROR(glEnableVertexAttribArray(a_linesofar));
CHECK_ERROR(glVertexAttribPointer(a_linesofar, 1, GL_SHORT, false, 8, offset + 6));
}

6
src/mbgl/shader/linejoin_shader.cpp
View File

@@ -17,11 +17,11 @@ LinejoinShader::LinejoinShader()
return;
}
a_pos = glGetAttribLocation(program, "a_pos");
a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
}
void LinejoinShader::bind(char *offset) {
glEnableVertexAttribArray(a_pos);
CHECK_ERROR(glEnableVertexAttribArray(a_pos));
// Note: We're referring to the vertices in a line array, which are 8 bytes long!
glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset);
CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset));
}

18
src/mbgl/shader/linepattern_shader.cpp
View File

@@ -18,18 +18,18 @@ LinepatternShader::LinepatternShader()
return;
}
a_pos = glGetAttribLocation(program, "a_pos");
a_extrude = glGetAttribLocation(program, "a_extrude");
a_linesofar = glGetAttribLocation(program, "a_linesofar");
a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
a_extrude = CHECK_ERROR(glGetAttribLocation(program, "a_extrude"));
a_linesofar = CHECK_ERROR(glGetAttribLocation(program, "a_linesofar"));
}
void LinepatternShader::bind(char *offset) {
glEnableVertexAttribArray(a_pos);
glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0);
CHECK_ERROR(glEnableVertexAttribArray(a_pos));
CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 8, offset + 0));
glEnableVertexAttribArray(a_extrude);
glVertexAttribPointer(a_extrude, 2, GL_BYTE, false, 8, offset + 4);
CHECK_ERROR(glEnableVertexAttribArray(a_extrude));
CHECK_ERROR(glVertexAttribPointer(a_extrude, 2, GL_BYTE, false, 8, offset + 4));
glEnableVertexAttribArray(a_linesofar);
glVertexAttribPointer(a_linesofar, 1, GL_SHORT, false, 8, offset + 6);
CHECK_ERROR(glEnableVertexAttribArray(a_linesofar));
CHECK_ERROR(glVertexAttribPointer(a_linesofar, 1, GL_SHORT, false, 8, offset + 6));
}

6
src/mbgl/shader/outline_shader.cpp
View File

@@ -17,10 +17,10 @@ OutlineShader::OutlineShader()
return;
}
a_pos = glGetAttribLocation(program, "a_pos");
a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
}
void OutlineShader::bind(char *offset) {
glEnableVertexAttribArray(a_pos);
glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset);
CHECK_ERROR(glEnableVertexAttribArray(a_pos));
CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
}

6
src/mbgl/shader/pattern_shader.cpp
View File

@@ -17,10 +17,10 @@ PatternShader::PatternShader()
return;
}
a_pos = glGetAttribLocation(program, "a_pos");
a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
}
void PatternShader::bind(char *offset) {
glEnableVertexAttribArray(a_pos);
glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset);
CHECK_ERROR(glEnableVertexAttribArray(a_pos));
CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
}

6
src/mbgl/shader/plain_shader.cpp
View File

@@ -17,10 +17,10 @@ PlainShader::PlainShader()
return;
}
a_pos = glGetAttribLocation(program, "a_pos");
a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
}
void PlainShader::bind(char *offset) {
glEnableVertexAttribArray(a_pos);
glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset);
CHECK_ERROR(glEnableVertexAttribArray(a_pos));
CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
}

6
src/mbgl/shader/raster_shader.cpp
View File

@@ -19,10 +19,10 @@ RasterShader::RasterShader()
return;
}
a_pos = glGetAttribLocation(program, "a_pos");
a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
}
void RasterShader::bind(char *offset) {
glEnableVertexAttribArray(a_pos);
glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset);
CHECK_ERROR(glEnableVertexAttribArray(a_pos));
CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, 0, offset));
}

90
src/mbgl/shader/sdf_shader.cpp
View File

@@ -17,75 +17,75 @@ SDFShader::SDFShader()
return;
}
a_pos = glGetAttribLocation(program, "a_pos");
a_offset = glGetAttribLocation(program, "a_offset");
a_tex = glGetAttribLocation(program, "a_tex");
a_angle = glGetAttribLocation(program, "a_angle");
a_minzoom = glGetAttribLocation(program, "a_minzoom");
a_maxzoom = glGetAttribLocation(program, "a_maxzoom");
a_rangeend = glGetAttribLocation(program, "a_rangeend");
a_rangestart = glGetAttribLocation(program, "a_rangestart");
a_labelminzoom = glGetAttribLocation(program, "a_labelminzoom");
a_pos = CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
a_offset = CHECK_ERROR(glGetAttribLocation(program, "a_offset"));
a_tex = CHECK_ERROR(glGetAttribLocation(program, "a_tex"));
a_angle = CHECK_ERROR(glGetAttribLocation(program, "a_angle"));
a_minzoom = CHECK_ERROR(glGetAttribLocation(program, "a_minzoom"));
a_maxzoom = CHECK_ERROR(glGetAttribLocation(program, "a_maxzoom"));
a_rangeend = CHECK_ERROR(glGetAttribLocation(program, "a_rangeend"));
a_rangestart = CHECK_ERROR(glGetAttribLocation(program, "a_rangestart"));
a_labelminzoom = CHECK_ERROR(glGetAttribLocation(program, "a_labelminzoom"));
}
void SDFGlyphShader::bind(char *offset) {
const int stride = 16;
glEnableVertexAttribArray(a_pos);
glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0);
CHECK_ERROR(glEnableVertexAttribArray(a_pos));
CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
glEnableVertexAttribArray(a_offset);
glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4);
CHECK_ERROR(glEnableVertexAttribArray(a_offset));
CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
glEnableVertexAttribArray(a_labelminzoom);
glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8);
CHECK_ERROR(glEnableVertexAttribArray(a_labelminzoom));
CHECK_ERROR(glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8));
glEnableVertexAttribArray(a_minzoom);
glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9);
CHECK_ERROR(glEnableVertexAttribArray(a_minzoom));
CHECK_ERROR(glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9));
glEnableVertexAttribArray(a_maxzoom);
glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10);
CHECK_ERROR(glEnableVertexAttribArray(a_maxzoom));
CHECK_ERROR(glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10));
glEnableVertexAttribArray(a_angle);
glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11);
CHECK_ERROR(glEnableVertexAttribArray(a_angle));
CHECK_ERROR(glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11));
glEnableVertexAttribArray(a_rangeend);
glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12);
CHECK_ERROR(glEnableVertexAttribArray(a_rangeend));
CHECK_ERROR(glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12));
glEnableVertexAttribArray(a_rangestart);
glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13);
CHECK_ERROR(glEnableVertexAttribArray(a_rangestart));
CHECK_ERROR(glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13));
glEnableVertexAttribArray(a_tex);
glVertexAttribPointer(a_tex, 2, GL_UNSIGNED_BYTE, false, stride, offset + 14);
CHECK_ERROR(glEnableVertexAttribArray(a_tex));
CHECK_ERROR(glVertexAttribPointer(a_tex, 2, GL_UNSIGNED_BYTE, false, stride, offset + 14));
}
void SDFIconShader::bind(char *offset) {
const int stride = 20;
glEnableVertexAttribArray(a_pos);
glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0);
CHECK_ERROR(glEnableVertexAttribArray(a_pos));
CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_SHORT, false, stride, offset + 0));
glEnableVertexAttribArray(a_offset);
glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4);
CHECK_ERROR(glEnableVertexAttribArray(a_offset));
CHECK_ERROR(glVertexAttribPointer(a_offset, 2, GL_SHORT, false, stride, offset + 4));
glEnableVertexAttribArray(a_labelminzoom);
glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8);
CHECK_ERROR(glEnableVertexAttribArray(a_labelminzoom));
CHECK_ERROR(glVertexAttribPointer(a_labelminzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 8));
glEnableVertexAttribArray(a_minzoom);
glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9);
CHECK_ERROR(glEnableVertexAttribArray(a_minzoom));
CHECK_ERROR(glVertexAttribPointer(a_minzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 9));
glEnableVertexAttribArray(a_maxzoom);
glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10);
CHECK_ERROR(glEnableVertexAttribArray(a_maxzoom));
CHECK_ERROR(glVertexAttribPointer(a_maxzoom, 1, GL_UNSIGNED_BYTE, false, stride, offset + 10));
glEnableVertexAttribArray(a_angle);
glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11);
CHECK_ERROR(glEnableVertexAttribArray(a_angle));
CHECK_ERROR(glVertexAttribPointer(a_angle, 1, GL_UNSIGNED_BYTE, false, stride, offset + 11));
glEnableVertexAttribArray(a_rangeend);
glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12);
CHECK_ERROR(glEnableVertexAttribArray(a_rangeend));
CHECK_ERROR(glVertexAttribPointer(a_rangeend, 1, GL_UNSIGNED_BYTE, false, stride, offset + 12));
glEnableVertexAttribArray(a_rangestart);
glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13);
CHECK_ERROR(glEnableVertexAttribArray(a_rangestart));
CHECK_ERROR(glVertexAttribPointer(a_rangestart, 1, GL_UNSIGNED_BYTE, false, stride, offset + 13));
glEnableVertexAttribArray(a_tex);
glVertexAttribPointer(a_tex, 2, GL_SHORT, false, stride, offset + 16);
CHECK_ERROR(glEnableVertexAttribArray(a_tex));
CHECK_ERROR(glVertexAttribPointer(a_tex, 2, GL_SHORT, false, stride, offset + 16));
}

78
src/mbgl/shader/shader.cpp
View File

@@ -16,7 +16,7 @@ Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSo
program(0) {
util::stopwatch stopwatch("shader compilation", Event::Shader);
program = glCreateProgram();
program = CHECK_ERROR(glCreateProgram());
if (!mbgl::platform::defaultShaderCache().empty()) {
binaryFileName = mbgl::platform::defaultShaderCache() + name + ".bin";
@@ -39,11 +39,11 @@ Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSo
bool binaryOk = fread(binary.get(), binaryLength, 1, binaryFile) == 1;
if (binaryOk) {
gl::ProgramBinary(program, binaryFormat, binary.get(), binaryLength);
CHECK_ERROR(gl::ProgramBinary(program, binaryFormat, binary.get(), binaryLength));
// Check if the binary was valid
GLint status;
glGetProgramiv(program, GL_LINK_STATUS, &status);
CHECK_ERROR(glGetProgramiv(program, GL_LINK_STATUS, &status));
if (status == GL_TRUE) {
skipCompile = true;
}
@@ -61,48 +61,48 @@ Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSo
if (!skipCompile) {
if (!compileShader(&vertShader, GL_VERTEX_SHADER, vertSource)) {
Log::Error(Event::Shader, "Vertex shader %s failed to compile: %s", name, vertSource);
glDeleteProgram(program);
CHECK_ERROR(glDeleteProgram(program));
program = 0;
return;
}
if (!compileShader(&fragShader, GL_FRAGMENT_SHADER, fragSource)) {
Log::Error(Event::Shader, "Fragment shader %s failed to compile: %s", name, fragSource);
glDeleteShader(vertShader);
CHECK_ERROR(glDeleteShader(vertShader));
vertShader = 0;
glDeleteProgram(program);
CHECK_ERROR(glDeleteProgram(program));
program = 0;
return;
}
// Attach shaders
glAttachShader(program, vertShader);
glAttachShader(program, fragShader);
CHECK_ERROR(glAttachShader(program, vertShader));
CHECK_ERROR(glAttachShader(program, fragShader));
{
if (!binaryFileName.empty() && (gl::ProgramParameteri != nullptr)) {
gl::ProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
CHECK_ERROR(gl::ProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE));
}
// Link program
GLint status;
glLinkProgram(program);
CHECK_ERROR(glLinkProgram(program));
glGetProgramiv(program, GL_LINK_STATUS, &status);
CHECK_ERROR(glGetProgramiv(program, GL_LINK_STATUS, &status));
if (status == 0) {
GLint logLength;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
CHECK_ERROR(glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength));
if (logLength > 0) {
std::unique_ptr<GLchar[]> log = mbgl::util::make_unique<GLchar[]>(logLength);
glGetProgramInfoLog(program, logLength, &logLength, log.get());
CHECK_ERROR(glGetProgramInfoLog(program, logLength, &logLength, log.get()));
Log::Error(Event::Shader, "Program failed to link: %s", log.get());
}
glDeleteShader(vertShader);
CHECK_ERROR(glDeleteShader(vertShader));
vertShader = 0;
glDeleteShader(fragShader);
CHECK_ERROR(glDeleteShader(fragShader));
fragShader = 0;
glDeleteProgram(program);
CHECK_ERROR(glDeleteProgram(program));
program = 0;
return;
}
@@ -112,33 +112,33 @@ Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSo
{
// Validate program
GLint status;
glValidateProgram(program);
CHECK_ERROR(glValidateProgram(program));
glGetProgramiv(program, GL_VALIDATE_STATUS, &status);
CHECK_ERROR(glGetProgramiv(program, GL_VALIDATE_STATUS, &status));
if (status == 0) {
GLint logLength;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
CHECK_ERROR(glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength));
if (logLength > 0) {
std::unique_ptr<GLchar[]> log = mbgl::util::make_unique<GLchar[]>(logLength);
glGetProgramInfoLog(program, logLength, &logLength, log.get());
CHECK_ERROR(glGetProgramInfoLog(program, logLength, &logLength, log.get()));
Log::Error(Event::Shader, "Program failed to validate: %s", log.get());
}
glDeleteShader(vertShader);
CHECK_ERROR(glDeleteShader(vertShader));
vertShader = 0;
glDeleteShader(fragShader);
CHECK_ERROR(glDeleteShader(fragShader));
fragShader = 0;
glDeleteProgram(program);
CHECK_ERROR(glDeleteProgram(program));
program = 0;
}
}
if (!skipCompile) {
// Remove the compiled shaders; they are now part of the program.
glDetachShader(program, vertShader);
glDeleteShader(vertShader);
glDetachShader(program, fragShader);
glDeleteShader(fragShader);
CHECK_ERROR(glDetachShader(program, vertShader));
CHECK_ERROR(glDeleteShader(vertShader));
CHECK_ERROR(glDetachShader(program, fragShader));
CHECK_ERROR(glDeleteShader(fragShader));
}
valid = true;
@@ -148,32 +148,32 @@ Shader::Shader(const char *name_, const GLchar *vertSource, const GLchar *fragSo
bool Shader::compileShader(GLuint *shader, GLenum type, const GLchar *source) {
GLint status;
*shader = glCreateShader(type);
*shader = CHECK_ERROR(glCreateShader(type));
const GLchar *strings[] = { source };
const GLsizei lengths[] = { (GLsizei)strlen(source) };
glShaderSource(*shader, 1, strings, lengths);
CHECK_ERROR(glShaderSource(*shader, 1, strings, lengths));
glCompileShader(*shader);
CHECK_ERROR(glCompileShader(*shader));
glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);
CHECK_ERROR(glGetShaderiv(*shader, GL_COMPILE_STATUS, &status));
if (status == 0) {
GLint logLength;
glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength);
CHECK_ERROR(glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength));
if (logLength > 0) {
std::unique_ptr<GLchar[]> log = mbgl::util::make_unique<GLchar[]>(logLength);
glGetShaderInfoLog(*shader, logLength, &logLength, log.get());
CHECK_ERROR(glGetShaderInfoLog(*shader, logLength, &logLength, log.get()));
Log::Error(Event::Shader, "Shader failed to compile: %s", log.get());
}
glDeleteShader(*shader);
CHECK_ERROR(glDeleteShader(*shader));
*shader = 0;
return false;
}
glGetShaderiv(*shader, GL_COMPILE_STATUS, &status);
CHECK_ERROR(glGetShaderiv(*shader, GL_COMPILE_STATUS, &status));
if (status == GL_FALSE) {
Log::Error(Event::Shader, "Shader %s failed to compile.", name, type);
glDeleteShader(*shader);
CHECK_ERROR(glDeleteShader(*shader));
*shader = 0;
return false;
}
@@ -186,11 +186,11 @@ Shader::~Shader() {
// Retrieve the program binary
GLsizei binaryLength;
GLenum binaryFormat;
glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binaryLength);
CHECK_ERROR(glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binaryLength));
if (binaryLength > 0) {
std::unique_ptr<char[]> binary = mbgl::util::make_unique<char[]>(binaryLength);
if (binary != nullptr) {
gl::GetProgramBinary(program, binaryLength, NULL, &binaryFormat, binary.get());
CHECK_ERROR(gl::GetProgramBinary(program, binaryLength, NULL, &binaryFormat, binary.get()));
// Write the binary to a file
FILE *binaryFile = fopen(binaryFileName.c_str(), "wb");
@@ -206,7 +206,7 @@ Shader::~Shader() {
}
if (program) {
glDeleteProgram(program);
CHECK_ERROR(glDeleteProgram(program));
program = 0;
valid = false;
}

16
src/mbgl/shader/uniform.cpp
View File

@@ -4,42 +4,42 @@ namespace mbgl {
template <>
void Uniform<float>::bind(const float& t) {
glUniform1f(location, t);
CHECK_ERROR(glUniform1f(location, t));
}
template <>
void Uniform<int32_t>::bind(const int32_t& t) {
glUniform1i(location, t);
CHECK_ERROR(glUniform1i(location, t));
}
template <>
void Uniform<std::array<float, 2>>::bind(const std::array<float, 2>& t) {
glUniform2fv(location, 1, t.data());
CHECK_ERROR(glUniform2fv(location, 1, t.data()));
}
template <>
void Uniform<std::array<float, 3>>::bind(const std::array<float, 3>& t) {
glUniform3fv(location, 1, t.data());
CHECK_ERROR(glUniform3fv(location, 1, t.data()));
}
template <>
void Uniform<std::array<float, 4>>::bind(const std::array<float, 4>& t) {
glUniform4fv(location, 1, t.data());
CHECK_ERROR(glUniform4fv(location, 1, t.data()));
}
template <>
void UniformMatrix<2>::bind(const std::array<float, 4>& t) {
glUniformMatrix2fv(location, 1, GL_FALSE, t.data());
CHECK_ERROR(glUniformMatrix2fv(location, 1, GL_FALSE, t.data()));
}
template <>
void UniformMatrix<3>::bind(const std::array<float, 9>& t) {
glUniformMatrix3fv(location, 1, GL_FALSE, t.data());
CHECK_ERROR(glUniformMatrix3fv(location, 1, GL_FALSE, t.data()));
}
template <>
void UniformMatrix<4>::bind(const std::array<float, 16>& t) {
glUniformMatrix4fv(location, 1, GL_FALSE, t.data());
CHECK_ERROR(glUniformMatrix4fv(location, 1, GL_FALSE, t.data()));
}
// Add more as needed.

10
src/mbgl/shader/uniform.hpp
View File

@@ -9,8 +9,9 @@ namespace mbgl {
template <typename T>
class Uniform {
public:
Uniform(const GLchar* name, const Shader& shader)
: location(glGetUniformLocation(shader.program, name)) {}
Uniform(const GLchar* name, const Shader& shader) {
location = CHECK_ERROR(glGetUniformLocation(shader.program, name));
}
void operator=(const T& t) {
if (current != t) {
@@ -31,8 +32,9 @@ class UniformMatrix {
public:
typedef std::array<float, C*R> T;
UniformMatrix(const GLchar* name, const Shader& shader)
: location(glGetUniformLocation(shader.program, name)) {}
UniformMatrix(const GLchar* name, const Shader& shader) {
location = CHECK_ERROR(glGetUniformLocation(shader.program, name));
}
void operator=(const T& t) {
if (current != t) {

30
src/mbgl/util/raster.cpp
View File

@@ -47,23 +47,23 @@ void Raster::bind(bool linear) {
if (img && !textured) {
texture = texturePool.getTextureID();
glBindTexture(GL_TEXTURE_2D, texture);
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
#ifndef GL_ES_VERSION_2_0
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
#endif
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->getData());
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
CHECK_ERROR(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->getData()));
img.reset();
textured = true;
} else if (textured) {
glBindTexture(GL_TEXTURE_2D, texture);
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture));
}
GLuint new_filter = linear ? GL_LINEAR : GL_NEAREST;
if (new_filter != this->filter) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, new_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, new_filter);
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, new_filter));
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, new_filter));
filter = new_filter;
}
}
@@ -71,20 +71,20 @@ void Raster::bind(bool linear) {
// overload ::bind for prerendered raster textures
void Raster::bind(const GLuint custom_texture) {
if (img && !textured) {
glBindTexture(GL_TEXTURE_2D, custom_texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->getData());
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, custom_texture));
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
CHECK_ERROR(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->getData()));
img.reset();
textured = true;
} else if (textured) {
glBindTexture(GL_TEXTURE_2D, custom_texture);
CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, custom_texture));
}
GLuint new_filter = GL_LINEAR;
if (new_filter != this->filter) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, new_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, new_filter);
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, new_filter));
CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, new_filter));
filter = new_filter;
}

4
src/mbgl/util/texture_pool.cpp
View File

@@ -9,7 +9,7 @@ using namespace mbgl;
GLuint TexturePool::getTextureID() {
if (texture_ids.empty()) {
GLuint new_texture_ids[TextureMax];
glGenTextures(TextureMax, new_texture_ids);
CHECK_ERROR(glGenTextures(TextureMax, new_texture_ids));
for (uint32_t id = 0; id < TextureMax; id++) {
texture_ids.insert(new_texture_ids[id]);
}
@@ -51,7 +51,7 @@ void TexturePool::clearTextureIDs() {
}
if (!ids_to_remove.empty()) {
glDeleteTextures((GLsizei)ids_to_remove.size(), &ids_to_remove[0]);
CHECK_ERROR(glDeleteTextures((GLsizei)ids_to_remove.size(), &ids_to_remove[0]));
}
texture_ids.clear();