From 5f496d8f0c235f99f795074d74381cdde264b570 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Wed, 22 Apr 2015 13:47:51 +0200 Subject: [PATCH 01/14] build render order array once instead of recursing through lots of different objects --- src/mbgl/map/raster_tile_data.cpp | 12 ++-- src/mbgl/map/raster_tile_data.hpp | 3 +- src/mbgl/map/source.cpp | 10 --- src/mbgl/map/source.hpp | 2 - src/mbgl/map/tile_data.hpp | 3 +- src/mbgl/map/vector_tile_data.cpp | 26 +++---- src/mbgl/map/vector_tile_data.hpp | 3 +- src/mbgl/renderer/painter.cpp | 115 ++++++++++++++---------------- src/mbgl/renderer/painter.hpp | 19 +++-- src/mbgl/style/style_layer.cpp | 15 ++++ src/mbgl/style/style_layer.hpp | 3 + 11 files changed, 105 insertions(+), 106 deletions(-) diff --git a/src/mbgl/map/raster_tile_data.cpp b/src/mbgl/map/raster_tile_data.cpp index 77ea8db89..6ab480401 100644 --- a/src/mbgl/map/raster_tile_data.cpp +++ b/src/mbgl/map/raster_tile_data.cpp @@ -23,10 +23,10 @@ void RasterTileData::parse() { } } -void RasterTileData::render(Painter &painter, const StyleLayer &layer_desc, const mat4 &matrix) { - bucket.render(painter, layer_desc, id, matrix); -} - -bool RasterTileData::hasData(StyleLayer const& /*layer_desc*/) const { - return bucket.hasData(); +Bucket* RasterTileData::getBucket(StyleLayer const&) { + if (bucket.hasData()) { + return &bucket; + } else { + return nullptr; + } } diff --git a/src/mbgl/map/raster_tile_data.hpp b/src/mbgl/map/raster_tile_data.hpp index dab2b7b84..45aee8f74 100644 --- a/src/mbgl/map/raster_tile_data.hpp +++ b/src/mbgl/map/raster_tile_data.hpp @@ -20,8 +20,7 @@ public: ~RasterTileData(); void parse() override; - void render(Painter &painter, const StyleLayer &layer_desc, const mat4 &matrix) override; - bool hasData(StyleLayer const &layer_desc) const override; + Bucket* getBucket(StyleLayer const &layer_desc) override; protected: StyleLayoutRaster layout; diff --git a/src/mbgl/map/source.cpp b/src/mbgl/map/source.cpp index 12684bb6c..6310a8588 100644 --- a/src/mbgl/map/source.cpp +++ b/src/mbgl/map/source.cpp @@ -184,16 +184,6 @@ void Source::drawClippingMasks(Painter &painter) { } } -void Source::render(Painter &painter, const StyleLayer &layer_desc) { - gl::group group(std::string { "layer: " } + layer_desc.id); - for (const auto& pair : tiles) { - Tile &tile = *pair.second; - if (tile.data && tile.data->state == TileData::State::parsed) { - painter.renderTileLayer(tile, layer_desc, tile.matrix); - } - } -} - void Source::finishRender(Painter &painter) { for (const auto& pair : tiles) { Tile &tile = *pair.second; diff --git a/src/mbgl/map/source.hpp b/src/mbgl/map/source.hpp index f7b675d16..fb2705aaf 100644 --- a/src/mbgl/map/source.hpp +++ b/src/mbgl/map/source.hpp @@ -29,7 +29,6 @@ class Sprite; class TexturePool; class Style; class Painter; -class StyleLayer; class TransformState; class Tile; struct ClipID; @@ -76,7 +75,6 @@ public: void updateMatrices(const mat4 &projMatrix, const TransformState &transform); void drawClippingMasks(Painter &painter); - void render(Painter &painter, const StyleLayer &layer_desc); void finishRender(Painter &painter); std::forward_list getLoadedTiles() const; diff --git a/src/mbgl/map/tile_data.hpp b/src/mbgl/map/tile_data.hpp index 92d9778fd..b85db7db7 100644 --- a/src/mbgl/map/tile_data.hpp +++ b/src/mbgl/map/tile_data.hpp @@ -47,8 +47,7 @@ public: // Override this in the child class. virtual void parse() = 0; - virtual void render(Painter &painter, const StyleLayer &layer_desc, const mat4 &matrix) = 0; - virtual bool hasData(StyleLayer const &layer_desc) const = 0; + virtual Bucket* getBucket(StyleLayer const &layer_desc) = 0; const TileID id; const std::string name; diff --git a/src/mbgl/map/vector_tile_data.cpp b/src/mbgl/map/vector_tile_data.cpp index 555e1851f..3dcbc0997 100644 --- a/src/mbgl/map/vector_tile_data.cpp +++ b/src/mbgl/map/vector_tile_data.cpp @@ -55,23 +55,15 @@ void VectorTileData::parse() { } } -void VectorTileData::render(Painter &painter, const StyleLayer &layer_desc, const mat4 &matrix) { - if (state == State::parsed && layer_desc.bucket) { - auto databucket_it = buckets.find(layer_desc.bucket->name); - if (databucket_it != buckets.end()) { - assert(databucket_it->second); - databucket_it->second->render(painter, layer_desc, id, matrix); +Bucket* VectorTileData::getBucket(StyleLayer const& layer) { + if (state == State::parsed && layer.bucket) { + const auto it = buckets.find(layer.bucket->name); + if (it != buckets.end()) { + assert(it->second); + if (it->second->hasData()) { + return it->second.get(); + } } } -} - -bool VectorTileData::hasData(const StyleLayer &layer_desc) const { - if (state == State::parsed && layer_desc.bucket) { - auto databucket_it = buckets.find(layer_desc.bucket->name); - if (databucket_it != buckets.end()) { - assert(databucket_it->second); - return databucket_it->second->hasData(); - } - } - return false; + return nullptr; } diff --git a/src/mbgl/map/vector_tile_data.hpp b/src/mbgl/map/vector_tile_data.hpp index 935ff9087..10eaf9c18 100644 --- a/src/mbgl/map/vector_tile_data.hpp +++ b/src/mbgl/map/vector_tile_data.hpp @@ -40,8 +40,7 @@ public: ~VectorTileData(); void parse() override; - void render(Painter &painter, const StyleLayer &layer_desc, const mat4 &matrix) override; - bool hasData(StyleLayer const& layer_desc) const override; + virtual Bucket* getBucket(StyleLayer const &layer_desc) override; protected: // Holds the actual geometries in this tile. diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp index 32d01c47f..903d12558 100644 --- a/src/mbgl/renderer/painter.cpp +++ b/src/mbgl/renderer/painter.cpp @@ -235,8 +235,11 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) // Actually render the layers if (debug::renderTree) { Log::Info(Event::Render, "{"); indent++; } + // Figure out what buckets we have to draw and what order we have to draw them in. + const auto order = determineRenderOrder(style); + // TODO: Correctly compute the number of layers recursively beforehand. - float strata_thickness = 1.0f / (style.layers.size() + 1); + const float strata_thickness = 1.0f / (order.size() + 1); // - FIRST PASS ------------------------------------------------------------ // Render everything top-to-bottom by using reverse iterators. Render opaque @@ -246,10 +249,16 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) Log::Info(Event::Render, "%*s%s", indent++ * 4, "", "OPAQUE {"); } int i = 0; - for (auto it = style.layers.rbegin(), end = style.layers.rend(); it != end; ++it, ++i) { - setOpaque(); - setStrata(i * strata_thickness); - renderLayer(**it); + setOpaque(); + for (auto it = order.rbegin(), end = order.rend(); it != end; ++it, ++i) { + const auto& item = *it; + if (item.bucket && item.tile) { + setStrata(i * strata_thickness); + prepareTile(*item.tile); + item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix); + } else { + renderBackground(item.layer); + } } if (debug::renderTree) { Log::Info(Event::Render, "%*s%s", --indent * 4, "", "}"); @@ -262,10 +271,14 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) Log::Info(Event::Render, "%*s%s", indent++ * 4, "", "TRANSLUCENT {"); } --i; - for (auto it = style.layers.begin(), end = style.layers.end(); it != end; ++it, --i) { - setTranslucent(); - setStrata(i * strata_thickness); - renderLayer(**it); + setTranslucent(); + for (auto it = order.begin(), end = order.end(); it != end; ++it, --i) { + const auto& item = *it; + if (item.bucket && item.tile) { + setStrata(i * strata_thickness); + prepareTile(*item.tile); + item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix); + } } if (debug::renderTree) { Log::Info(Event::Render, "%*s%s", --indent * 4, "", "}"); @@ -282,76 +295,58 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) } } -void Painter::renderLayer(const StyleLayer &layer_desc) { - if (layer_desc.bucket->visibility == VisibilityType::None) return; - if (layer_desc.type == StyleLayerType::Background) { - // This layer defines a background color/image. +std::vector Painter::determineRenderOrder(const Style& style) { + std::vector order; - if (debug::renderTree) { - Log::Info(Event::Render, "%*s- %s (%s)", indent * 4, "", layer_desc.id.c_str(), - StyleLayerTypeClass(layer_desc.type).c_str()); + for (const auto& layerPtr : style.layers) { + const auto& layer = *layerPtr; + if (layer.bucket->visibility == VisibilityType::None) continue; + if (layer.type == StyleLayerType::Background) { + // This layer defines a background color/image. + order.emplace_back(layer); + continue; } - renderBackground(layer_desc); - } else { // This is a singular layer. - if (!layer_desc.bucket) { - Log::Warning(Event::Render, "layer '%s' is missing bucket", layer_desc.id.c_str()); - return; + if (!layer.bucket) { + Log::Warning(Event::Render, "layer '%s' is missing bucket", layer.id.c_str()); + continue; } - if (!layer_desc.bucket->source) { - Log::Warning(Event::Render, "can't find source for layer '%s'", layer_desc.id.c_str()); - return; + if (!layer.bucket->source) { + Log::Warning(Event::Render, "can't find source for layer '%s'", layer.id.c_str()); + continue; } // Skip this layer if it's outside the range of min/maxzoom. // This may occur when there /is/ a bucket created for this layer, but the min/max-zoom // is set to a fractional value, or value that is larger than the source maxzoom. const double zoom = state.getZoom(); - if (layer_desc.bucket->min_zoom > zoom || - layer_desc.bucket->max_zoom <= zoom) { - return; + if (layer.bucket->min_zoom > zoom || + layer.bucket->max_zoom <= zoom) { + continue; } - // Abort early if we can already deduce from the bucket type that - // we're not going to render anything anyway during this pass. - switch (layer_desc.type) { - case StyleLayerType::Fill: - if (!layer_desc.getProperties().isVisible()) return; - break; - case StyleLayerType::Line: - if (pass == RenderPass::Opaque) return; - if (!layer_desc.getProperties().isVisible()) return; - break; - case StyleLayerType::Symbol: - if (pass == RenderPass::Opaque) return; - if (!layer_desc.getProperties().isVisible()) return; - break; - case StyleLayerType::Raster: - if (pass == RenderPass::Opaque) return; - if (!layer_desc.getProperties().isVisible()) return; - break; - default: - break; + // Don't include invisible layers. + if (!layer.isVisible()) { + continue; } - if (debug::renderTree) { - Log::Info(Event::Render, "%*s- %s (%s)", indent * 4, "", layer_desc.id.c_str(), - StyleLayerTypeClass(layer_desc.type).c_str()); - } + auto tiles = layer.bucket->source->getLoadedTiles(); + for (auto tile : tiles) { + assert(tile); + if (!tile->data) { + continue; + } - layer_desc.bucket->source->render(*this, layer_desc); + auto bucket = tile->data->getBucket(layer); + if (bucket) { + order.emplace_back(layer, tile, bucket); + } + } } -} -void Painter::renderTileLayer(const Tile& tile, const StyleLayer &layer_desc, const mat4 &matrix) { - assert(tile.data); - if (tile.data->hasData(layer_desc) || layer_desc.type == StyleLayerType::Raster) { - gl::group group(std::string { "render " } + tile.data->name); - prepareTile(tile); - tile.data->render(*this, layer_desc, matrix); - } + return order; } void Painter::renderBackground(const StyleLayer &layer_desc) { diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp index e7e5557eb..be21ef2b6 100644 --- a/src/mbgl/renderer/painter.hpp +++ b/src/mbgl/renderer/painter.hpp @@ -57,6 +57,18 @@ class GaussianShader; struct ClipID; +struct RenderItem { + inline RenderItem(const StyleLayer& layer_, + const Tile* tile_ = nullptr, + Bucket* bucket_ = nullptr) + : tile(tile_), bucket(bucket_), layer(layer_) { + } + + const Tile* const tile; + Bucket* const bucket; + const StyleLayer& layer; +}; + class Painter : private util::noncopyable { public: Painter(SpriteAtlas&, GlyphAtlas&, LineAtlas&); @@ -75,11 +87,6 @@ public: TransformState state, TimePoint time); - void renderLayer(const StyleLayer&); - - // Renders a particular layer from a tile. - void renderTileLayer(const Tile& tile, const StyleLayer &layer_desc, const mat4 &matrix); - // Renders debug information for a tile. void renderTileDebug(const Tile& tile); @@ -131,6 +138,8 @@ private: void setupShaders(); mat4 translatedMatrix(const mat4& matrix, const std::array &translation, const TileID &id, TranslateAnchorType anchor); + std::vector determineRenderOrder(const Style& style); + void prepareTile(const Tile& tile); template diff --git a/src/mbgl/style/style_layer.cpp b/src/mbgl/style/style_layer.cpp index e9c301d8c..8713b73b1 100644 --- a/src/mbgl/style/style_layer.cpp +++ b/src/mbgl/style/style_layer.cpp @@ -13,6 +13,21 @@ bool StyleLayer::isBackground() const { return type == StyleLayerType::Background; } +bool StyleLayer::isVisible() const { + switch (type) { + case StyleLayerType::Fill: + return getProperties().isVisible(); + case StyleLayerType::Line: + return getProperties().isVisible(); + case StyleLayerType::Symbol: + return getProperties().isVisible(); + case StyleLayerType::Raster: + return getProperties().isVisible(); + default: + return false; + } +} + void StyleLayer::setClasses(const std::vector &class_names, const TimePoint now, const PropertyTransition &defaultTransition) { // Stores all keys that we have already added transitions for. diff --git a/src/mbgl/style/style_layer.hpp b/src/mbgl/style/style_layer.hpp index a00b7084f..774ed3901 100644 --- a/src/mbgl/style/style_layer.hpp +++ b/src/mbgl/style/style_layer.hpp @@ -35,6 +35,9 @@ public: // Determines whether this layer is the background layer. bool isBackground() const; + // Checks whether the layer is currently visible at all. + bool isVisible() const; + // Updates the StyleProperties information in this layer by evaluating all // pending transitions and applied classes in order. void updateProperties(float z, TimePoint now, ZoomHistory &zoomHistory); From 5beb635028b6634f57ae874a416a291999f31e97 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Wed, 22 Apr 2015 14:31:26 +0200 Subject: [PATCH 02/14] create the tile list statically --- src/mbgl/map/source.cpp | 13 +++++++++++++ src/mbgl/map/source.hpp | 3 +++ src/mbgl/renderer/painter.cpp | 4 ++-- 3 files changed, 18 insertions(+), 2 deletions(-) diff --git a/src/mbgl/map/source.cpp b/src/mbgl/map/source.cpp index 6310a8588..708ff6b27 100644 --- a/src/mbgl/map/source.cpp +++ b/src/mbgl/map/source.cpp @@ -202,6 +202,9 @@ std::forward_list Source::getLoadedTiles() const { return ptrs; } +const std::vector& Source::getTiles() const { + return tilePtrs; +} TileData::State Source::hasTile(const TileID& id) { auto it = tiles.find(id); @@ -445,6 +448,8 @@ void Source::update(MapData& data, } }); + updateTilePtrs(); + updated = data.getAnimationTime(); } @@ -454,6 +459,14 @@ void Source::invalidateTiles(const std::vector& ids) { tiles.erase(id); tile_data.erase(id); } + updateTilePtrs(); +} + +void Source::updateTilePtrs() { + tilePtrs.clear(); + for (const auto& pair : tiles) { + tilePtrs.push_back(pair.second.get()); + } } void Source::setCacheSize(size_t size) { diff --git a/src/mbgl/map/source.hpp b/src/mbgl/map/source.hpp index fb2705aaf..b15de0e64 100644 --- a/src/mbgl/map/source.hpp +++ b/src/mbgl/map/source.hpp @@ -78,6 +78,7 @@ public: void finishRender(Painter &painter); std::forward_list getLoadedTiles() const; + const std::vector& getTiles() const; void setCacheSize(size_t); void onLowMemory(); @@ -103,6 +104,7 @@ private: std::function callback); TileData::State hasTile(const TileID& id); + void updateTilePtrs(); double getZoom(const TransformState &state) const; @@ -112,6 +114,7 @@ private: TimePoint updated = TimePoint::min(); std::map> tiles; + std::vector tilePtrs; std::map> tile_data; TileCache cache; }; diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp index 903d12558..74ad8b477 100644 --- a/src/mbgl/renderer/painter.cpp +++ b/src/mbgl/renderer/painter.cpp @@ -332,10 +332,10 @@ std::vector Painter::determineRenderOrder(const Style& style) { continue; } - auto tiles = layer.bucket->source->getLoadedTiles(); + const auto& tiles = layer.bucket->source->getTiles(); for (auto tile : tiles) { assert(tile); - if (!tile->data) { + if (!tile->data && !tile->data->ready()) { continue; } From c891df0b5f3e946840324dbe238f29c1fba16ea3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Wed, 22 Apr 2015 17:52:10 +0200 Subject: [PATCH 03/14] add upload API to gl objects --- src/mbgl/geometry/buffer.hpp | 22 +++++++++++++-------- src/mbgl/map/tile_parser.cpp | 6 +++--- src/mbgl/renderer/raster_bucket.cpp | 7 ------- src/mbgl/renderer/raster_bucket.hpp | 2 -- src/mbgl/util/raster.cpp | 30 +++++++---------------------- src/mbgl/util/raster.hpp | 4 ++-- 6 files changed, 26 insertions(+), 45 deletions(-) diff --git a/src/mbgl/geometry/buffer.hpp b/src/mbgl/geometry/buffer.hpp index 4198425ec..01af5df18 100644 --- a/src/mbgl/geometry/buffer.hpp +++ b/src/mbgl/geometry/buffer.hpp @@ -2,6 +2,7 @@ #define MBGL_GEOMETRY_BUFFER #include +#include #include #include @@ -38,17 +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) { + void bind() { + if (buffer) { + MBGL_CHECK_ERROR(glBindBuffer(bufferType, buffer)); + } else { MBGL_CHECK_ERROR(glGenBuffers(1, &buffer)); - force = true; - } - MBGL_CHECK_ERROR(glBindBuffer(bufferType, buffer)); - if (force) { + MBGL_CHECK_ERROR(glBindBuffer(bufferType, buffer)); if (array == nullptr) { - throw std::runtime_error("Buffer was already deleted or doesn't contain elements"); + Log::Debug(Event::OpenGL, "Buffer doesn't contain elements"); + pos = 0; } - MBGL_CHECK_ERROR(glBufferData(bufferType, pos, array, GL_STATIC_DRAW)); if (!retainAfterUpload) { cleanup(); @@ -67,6 +67,12 @@ public: return buffer; } + inline void upload() { + if (!buffer) { + bind(); + } + } + protected: // increase the buffer size by at least /required/ bytes. inline void *addElement() { diff --git a/src/mbgl/map/tile_parser.cpp b/src/mbgl/map/tile_parser.cpp index 35c504ab2..1438bcdda 100644 --- a/src/mbgl/map/tile_parser.cpp +++ b/src/mbgl/map/tile_parser.cpp @@ -157,7 +157,7 @@ std::unique_ptr TileParser::createFillBucket(const GeometryTileLayer& la tile.triangleElementsBuffer, tile.lineElementsBuffer); addBucketGeometries(bucket, layer, bucket_desc.filter); - return std::move(bucket); + return bucket->hasData() ? std::move(bucket) : nullptr; } std::unique_ptr TileParser::createLineBucket(const GeometryTileLayer& layer, @@ -174,7 +174,7 @@ std::unique_ptr TileParser::createLineBucket(const GeometryTileLayer& la applyLayoutProperty(PropertyKey::LineRoundLimit, bucket_desc.layout, layout.round_limit, z); addBucketGeometries(bucket, layer, bucket_desc.filter); - return std::move(bucket); + return bucket->hasData() ? std::move(bucket) : nullptr; } std::unique_ptr TileParser::createSymbolBucket(const GeometryTileLayer& layer, @@ -224,6 +224,6 @@ std::unique_ptr TileParser::createSymbolBucket(const GeometryTileLayer& bucket->addFeatures( layer, bucket_desc.filter, reinterpret_cast(&tile), spriteAtlas, *sprite, glyphAtlas, glyphStore); - return std::move(bucket); + return bucket->hasData() ? std::move(bucket) : nullptr; } } diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp index cf1036dbf..bcaf6e7da 100644 --- a/src/mbgl/renderer/raster_bucket.cpp +++ b/src/mbgl/renderer/raster_bucket.cpp @@ -29,13 +29,6 @@ void RasterBucket::drawRaster(RasterShader& shader, StaticVertexBuffer &vertices MBGL_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)); - MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices.index())); -} - bool RasterBucket::hasData() const { return raster.isLoaded(); } diff --git a/src/mbgl/renderer/raster_bucket.hpp b/src/mbgl/renderer/raster_bucket.hpp index ed2d46bb2..d216404ca 100644 --- a/src/mbgl/renderer/raster_bucket.hpp +++ b/src/mbgl/renderer/raster_bucket.hpp @@ -26,8 +26,6 @@ public: void drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array); - void drawRaster(RasterShader& shader, StaticVertexBuffer &vertices, VertexArrayObject &array, GLuint texture); - Raster raster; }; diff --git a/src/mbgl/util/raster.cpp b/src/mbgl/util/raster.cpp index d0e305c33..f2171a616 100644 --- a/src/mbgl/util/raster.cpp +++ b/src/mbgl/util/raster.cpp @@ -46,16 +46,7 @@ void Raster::bind(bool linear) { } if (img && !textured) { - texture = texturePool.getTextureID(); - MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture)); -#ifndef GL_ES_VERSION_2_0 - MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)); -#endif - MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); - MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); - MBGL_CHECK_ERROR(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img->getData())); - img.reset(); - textured = true; + upload(); } else if (textured) { MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture)); } @@ -68,24 +59,17 @@ void Raster::bind(bool linear) { } } -// overload ::bind for prerendered raster textures -void Raster::bind(const GLuint custom_texture) { +void Raster::upload() { if (img && !textured) { - MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, custom_texture)); + texture = texturePool.getTextureID(); + MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture)); +#ifndef GL_ES_VERSION_2_0 + MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0)); +#endif MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); MBGL_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) { - MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, custom_texture)); } - - GLuint new_filter = GL_LINEAR; - if (new_filter != this->filter) { - MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, new_filter)); - MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, new_filter)); - filter = new_filter; - } - } diff --git a/src/mbgl/util/raster.hpp b/src/mbgl/util/raster.hpp index f19ff7178..1789ae87f 100644 --- a/src/mbgl/util/raster.hpp +++ b/src/mbgl/util/raster.hpp @@ -25,8 +25,8 @@ public: // bind current texture void bind(bool linear = false); - // bind prerendered texture - void bind(const GLuint texture); + // uploads the texture if it hasn't been uploaded yet. + void upload(); // loaded status bool isLoaded() const; From 839b19330ee7ca1b3cd42cf77dc4caa08eaf0a63 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Wed, 22 Apr 2015 18:07:27 +0200 Subject: [PATCH 04/14] remove hasData() from Bucket interface --- src/mbgl/map/raster_tile_data.cpp | 6 +----- src/mbgl/map/vector_tile_data.cpp | 4 +--- src/mbgl/renderer/bucket.hpp | 1 - src/mbgl/renderer/debug_bucket.cpp | 4 ---- src/mbgl/renderer/debug_bucket.hpp | 1 - src/mbgl/renderer/fill_bucket.hpp | 2 +- src/mbgl/renderer/line_bucket.hpp | 2 +- src/mbgl/renderer/painter_fill.cpp | 3 --- src/mbgl/renderer/painter_line.cpp | 1 - src/mbgl/renderer/raster_bucket.hpp | 2 +- src/mbgl/renderer/symbol_bucket.hpp | 2 +- 11 files changed, 6 insertions(+), 22 deletions(-) diff --git a/src/mbgl/map/raster_tile_data.cpp b/src/mbgl/map/raster_tile_data.cpp index 6ab480401..0b849ca7c 100644 --- a/src/mbgl/map/raster_tile_data.cpp +++ b/src/mbgl/map/raster_tile_data.cpp @@ -24,9 +24,5 @@ void RasterTileData::parse() { } Bucket* RasterTileData::getBucket(StyleLayer const&) { - if (bucket.hasData()) { - return &bucket; - } else { - return nullptr; - } + return &bucket; } diff --git a/src/mbgl/map/vector_tile_data.cpp b/src/mbgl/map/vector_tile_data.cpp index 3dcbc0997..4c6c1150b 100644 --- a/src/mbgl/map/vector_tile_data.cpp +++ b/src/mbgl/map/vector_tile_data.cpp @@ -60,9 +60,7 @@ Bucket* VectorTileData::getBucket(StyleLayer const& layer) { const auto it = buckets.find(layer.bucket->name); if (it != buckets.end()) { assert(it->second); - if (it->second->hasData()) { - return it->second.get(); - } + return it->second.get(); } } return nullptr; diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp index a7b0f61a3..2ea73f9b9 100644 --- a/src/mbgl/renderer/bucket.hpp +++ b/src/mbgl/renderer/bucket.hpp @@ -13,7 +13,6 @@ class TileID; class Bucket : private util::noncopyable { public: virtual void render(Painter&, const StyleLayer&, const TileID&, const mat4&) = 0; - virtual bool hasData() const = 0; virtual ~Bucket() {} }; diff --git a/src/mbgl/renderer/debug_bucket.cpp b/src/mbgl/renderer/debug_bucket.cpp index 0c5fc63a2..a8a8acc3d 100644 --- a/src/mbgl/renderer/debug_bucket.cpp +++ b/src/mbgl/renderer/debug_bucket.cpp @@ -21,10 +21,6 @@ void DebugBucket::render(Painter &painter, const StyleLayer & /*layer_desc*/, painter.renderDebugText(*this, matrix); } -bool DebugBucket::hasData() const { - return fontBuffer.index() > 0; -} - void DebugBucket::drawLines(PlainShader& shader) { array.bind(shader, fontBuffer, BUFFER_OFFSET(0)); MBGL_CHECK_ERROR(glDrawArrays(GL_LINES, 0, (GLsizei)(fontBuffer.index()))); diff --git a/src/mbgl/renderer/debug_bucket.hpp b/src/mbgl/renderer/debug_bucket.hpp index 9f20051e4..24cc88b26 100644 --- a/src/mbgl/renderer/debug_bucket.hpp +++ b/src/mbgl/renderer/debug_bucket.hpp @@ -17,7 +17,6 @@ public: void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, const mat4 &matrix) override; - bool hasData() const override; void drawLines(PlainShader& shader); void drawPoints(PlainShader& shader); diff --git a/src/mbgl/renderer/fill_bucket.hpp b/src/mbgl/renderer/fill_bucket.hpp index 18eb5886c..0d7d7ab93 100644 --- a/src/mbgl/renderer/fill_bucket.hpp +++ b/src/mbgl/renderer/fill_bucket.hpp @@ -35,7 +35,7 @@ public: void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, const mat4 &matrix) override; - bool hasData() const override; + bool hasData() const; void addGeometry(const GeometryCollection&); void tessellate(); diff --git a/src/mbgl/renderer/line_bucket.hpp b/src/mbgl/renderer/line_bucket.hpp index 64f353d7c..4a83fdace 100644 --- a/src/mbgl/renderer/line_bucket.hpp +++ b/src/mbgl/renderer/line_bucket.hpp @@ -30,7 +30,7 @@ public: void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, const mat4 &matrix) override; - bool hasData() const override; + bool hasData() const; void addGeometry(const GeometryCollection&); void addGeometry(const std::vector& line); diff --git a/src/mbgl/renderer/painter_fill.cpp b/src/mbgl/renderer/painter_fill.cpp index 459aa148a..1c5dd88b9 100644 --- a/src/mbgl/renderer/painter_fill.cpp +++ b/src/mbgl/renderer/painter_fill.cpp @@ -15,9 +15,6 @@ using namespace mbgl; void Painter::renderFill(FillBucket& bucket, const StyleLayer &layer_desc, const TileID& id, const mat4 &matrix) { - // Abort early. - if (!bucket.hasData()) return; - const FillProperties &properties = layer_desc.getProperties(); mat4 vtxMatrix = translatedMatrix(matrix, properties.translate, id, properties.translateAnchor); diff --git a/src/mbgl/renderer/painter_line.cpp b/src/mbgl/renderer/painter_line.cpp index 1d18b7ded..929ba5c5d 100644 --- a/src/mbgl/renderer/painter_line.cpp +++ b/src/mbgl/renderer/painter_line.cpp @@ -16,7 +16,6 @@ using namespace mbgl; void Painter::renderLine(LineBucket& bucket, const StyleLayer &layer_desc, const TileID& id, const mat4 &matrix) { // Abort early. if (pass == RenderPass::Opaque) return; - if (!bucket.hasData()) return; depthMask(false); diff --git a/src/mbgl/renderer/raster_bucket.hpp b/src/mbgl/renderer/raster_bucket.hpp index d216404ca..26a216ae3 100644 --- a/src/mbgl/renderer/raster_bucket.hpp +++ b/src/mbgl/renderer/raster_bucket.hpp @@ -18,7 +18,7 @@ public: void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, const mat4 &matrix) override; - bool hasData() const override; + bool hasData() const; bool setImage(const std::string &data); diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp index 9ddd653c5..c54a59321 100644 --- a/src/mbgl/renderer/symbol_bucket.hpp +++ b/src/mbgl/renderer/symbol_bucket.hpp @@ -57,7 +57,7 @@ public: void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, const mat4 &matrix) override; - bool hasData() const override; + bool hasData() const; bool hasTextData() const; bool hasIconData() const; From 28b9b3f9d64207a03b6125b3e299efda59952a03 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Wed, 22 Apr 2015 18:27:19 +0200 Subject: [PATCH 05/14] add prepare() function --- src/mbgl/renderer/bucket.hpp | 21 +++++++++++++++++++++ src/mbgl/renderer/debug_bucket.cpp | 6 ++++-- src/mbgl/renderer/debug_bucket.hpp | 4 ++-- src/mbgl/renderer/fill_bucket.cpp | 9 +++++++-- src/mbgl/renderer/fill_bucket.hpp | 4 ++-- src/mbgl/renderer/line_bucket.cpp | 3 +++ src/mbgl/renderer/line_bucket.hpp | 4 ++-- src/mbgl/renderer/painter.hpp | 3 +-- src/mbgl/renderer/raster_bucket.cpp | 9 +++++++-- src/mbgl/renderer/raster_bucket.hpp | 4 ++-- src/mbgl/renderer/symbol_bucket.cpp | 9 +++++++-- src/mbgl/renderer/symbol_bucket.hpp | 4 ++-- 12 files changed, 60 insertions(+), 20 deletions(-) diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp index 2ea73f9b9..282a6aa36 100644 --- a/src/mbgl/renderer/bucket.hpp +++ b/src/mbgl/renderer/bucket.hpp @@ -10,11 +10,32 @@ class Painter; class StyleLayer; class TileID; +enum class RenderPass : uint8_t { + Prepare = 1 << 0, + Opaque = 1 << 1, + Translucent = 1 << 2, +}; + class Bucket : private util::noncopyable { public: + // As long as this bucket has a Prepare render pass, this function is getting called. Typically, + // this only happens once when the bucket is being rendered for the first time. + virtual void prepare() = 0; + + // Every time this bucket is getting rendered, this function is called. This happens either + // once or twice (for Opaque and Transparent render passes). virtual void render(Painter&, const StyleLayer&, const TileID&, const mat4&) = 0; + virtual ~Bucket() {} + inline bool hasRenderPass(RenderPass pass) const { + return static_cast::type>(renderPass) & + static_cast::type>(pass); + } + +protected: + RenderPass renderPass = RenderPass::Prepare; + }; } diff --git a/src/mbgl/renderer/debug_bucket.cpp b/src/mbgl/renderer/debug_bucket.cpp index a8a8acc3d..7e367a95b 100644 --- a/src/mbgl/renderer/debug_bucket.cpp +++ b/src/mbgl/renderer/debug_bucket.cpp @@ -16,8 +16,10 @@ DebugBucket::DebugBucket(DebugFontBuffer& fontBuffer_) : fontBuffer(fontBuffer_) { } -void DebugBucket::render(Painter &painter, const StyleLayer & /*layer_desc*/, - const TileID & /*id*/, const mat4 &matrix) { +void DebugBucket::prepare() { +} + +void DebugBucket::render(Painter& painter, const StyleLayer&, const TileID&, const mat4& matrix) { painter.renderDebugText(*this, matrix); } diff --git a/src/mbgl/renderer/debug_bucket.hpp b/src/mbgl/renderer/debug_bucket.hpp index 24cc88b26..784530337 100644 --- a/src/mbgl/renderer/debug_bucket.hpp +++ b/src/mbgl/renderer/debug_bucket.hpp @@ -15,8 +15,8 @@ class DebugBucket : public Bucket { public: DebugBucket(DebugFontBuffer& fontBuffer); - void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, - const mat4 &matrix) override; + void prepare() override; + void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override; void drawLines(PlainShader& shader); void drawPoints(PlainShader& shader); diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp index 77b7b1188..f8e604ee2 100644 --- a/src/mbgl/renderer/fill_bucket.cpp +++ b/src/mbgl/renderer/fill_bucket.cpp @@ -200,8 +200,13 @@ void FillBucket::tessellate() { lineGroup.vertex_length += total_vertex_count; } -void FillBucket::render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, - const mat4 &matrix) { +void FillBucket::prepare() { +} + +void FillBucket::render(Painter& painter, + const StyleLayer& layer_desc, + const TileID& id, + const mat4& matrix) { painter.renderFill(*this, layer_desc, id, matrix); } diff --git a/src/mbgl/renderer/fill_bucket.hpp b/src/mbgl/renderer/fill_bucket.hpp index 0d7d7ab93..579b04acf 100644 --- a/src/mbgl/renderer/fill_bucket.hpp +++ b/src/mbgl/renderer/fill_bucket.hpp @@ -33,8 +33,8 @@ public: LineElementsBuffer &lineElementsBuffer); ~FillBucket() override; - void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, - const mat4 &matrix) override; + void prepare() override; + void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override; bool hasData() const; void addGeometry(const GeometryCollection&); diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp index 97237901f..8e3a8ce9c 100644 --- a/src/mbgl/renderer/line_bucket.cpp +++ b/src/mbgl/renderer/line_bucket.cpp @@ -342,6 +342,9 @@ void LineBucket::addCurrentVertex(const Coordinate& currentVertex, e2 = e3; } +void LineBucket::prepare() { +} + void LineBucket::render(Painter& painter, const StyleLayer& layer_desc, const TileID& id, diff --git a/src/mbgl/renderer/line_bucket.hpp b/src/mbgl/renderer/line_bucket.hpp index 4a83fdace..9999fb637 100644 --- a/src/mbgl/renderer/line_bucket.hpp +++ b/src/mbgl/renderer/line_bucket.hpp @@ -28,8 +28,8 @@ public: LineBucket(LineVertexBuffer &vertexBuffer, TriangleElementsBuffer &triangleElementsBuffer); ~LineBucket() override; - void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, - const mat4 &matrix) override; + void prepare() override; + void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override; bool hasData() const; void addGeometry(const GeometryCollection&); diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp index be21ef2b6..7010a933b 100644 --- a/src/mbgl/renderer/painter.hpp +++ b/src/mbgl/renderer/painter.hpp @@ -4,6 +4,7 @@ #include #include +#include #include #include @@ -21,8 +22,6 @@ namespace mbgl { -enum class RenderPass : bool { Opaque, Translucent }; - class Style; class StyleLayer; class Tile; diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp index bcaf6e7da..7f1f92b5c 100644 --- a/src/mbgl/renderer/raster_bucket.cpp +++ b/src/mbgl/renderer/raster_bucket.cpp @@ -13,8 +13,13 @@ RasterBucket::RasterBucket(TexturePool& texturePool, const StyleLayoutRaster& la raster(texturePool) { } -void RasterBucket::render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, - const mat4 &matrix) { +void RasterBucket::prepare() { +} + +void RasterBucket::render(Painter& painter, + const StyleLayer& layer_desc, + const TileID& id, + const mat4& matrix) { painter.renderRaster(*this, layer_desc, id, matrix); } diff --git a/src/mbgl/renderer/raster_bucket.hpp b/src/mbgl/renderer/raster_bucket.hpp index 26a216ae3..3faece546 100644 --- a/src/mbgl/renderer/raster_bucket.hpp +++ b/src/mbgl/renderer/raster_bucket.hpp @@ -16,8 +16,8 @@ class RasterBucket : public Bucket { public: RasterBucket(TexturePool&, const StyleLayoutRaster&); - void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, - const mat4 &matrix) override; + void prepare() override; + void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override; bool hasData() const; bool setImage(const std::string &data); diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp index 6d6176196..d520e4de2 100644 --- a/src/mbgl/renderer/symbol_bucket.cpp +++ b/src/mbgl/renderer/symbol_bucket.cpp @@ -36,8 +36,13 @@ SymbolBucket::~SymbolBucket() { // Do not remove. header file only contains forward definitions to unique pointers. } -void SymbolBucket::render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, - const mat4 &matrix) { +void SymbolBucket::prepare() { +} + +void SymbolBucket::render(Painter& painter, + const StyleLayer& layer_desc, + const TileID& id, + const mat4& matrix) { painter.renderSymbol(*this, layer_desc, id, matrix); } diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp index c54a59321..1c05150f4 100644 --- a/src/mbgl/renderer/symbol_bucket.hpp +++ b/src/mbgl/renderer/symbol_bucket.hpp @@ -55,8 +55,8 @@ public: SymbolBucket(Collision &collision); ~SymbolBucket() override; - void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id, - const mat4 &matrix) override; + void prepare() override; + void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override; bool hasData() const; bool hasTextData() const; bool hasIconData() const; From 97a22b6f5fea5666025189231f5fecc4946ceb0b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Thu, 23 Apr 2015 11:39:12 +0200 Subject: [PATCH 06/14] upload all GL objects before rendering a frame This moves all texture updates and buffer uploads to the beginning of every frame, before we issue any drawing commands. This means the GPU typically has much more time to upload the data in the background until we actually need it, and doesn't have to pause to store/load the framebuffer. --- src/mbgl/geometry/buffer.hpp | 1 + src/mbgl/geometry/glyph_atlas.cpp | 6 +++ src/mbgl/geometry/glyph_atlas.hpp | 5 +++ src/mbgl/geometry/line_atlas.cpp | 6 +++ src/mbgl/geometry/line_atlas.hpp | 5 +++ src/mbgl/geometry/sprite_atlas.cpp | 6 +++ src/mbgl/geometry/sprite_atlas.hpp | 7 ++- src/mbgl/renderer/debug_bucket.cpp | 3 ++ src/mbgl/renderer/fill_bucket.cpp | 8 ++++ src/mbgl/renderer/line_bucket.cpp | 5 +++ src/mbgl/renderer/painter.cpp | 66 ++++++++++++++++++++--------- src/mbgl/renderer/raster_bucket.cpp | 3 ++ src/mbgl/renderer/symbol_bucket.cpp | 11 +++++ 13 files changed, 111 insertions(+), 21 deletions(-) diff --git a/src/mbgl/geometry/buffer.hpp b/src/mbgl/geometry/buffer.hpp index 01af5df18..7e3ced442 100644 --- a/src/mbgl/geometry/buffer.hpp +++ b/src/mbgl/geometry/buffer.hpp @@ -67,6 +67,7 @@ public: return buffer; } + // Uploads the buffer to the GPU to be available when we need it. inline void upload() { if (!buffer) { bind(); diff --git a/src/mbgl/geometry/glyph_atlas.cpp b/src/mbgl/geometry/glyph_atlas.cpp index f690004b5..378664f30 100644 --- a/src/mbgl/geometry/glyph_atlas.cpp +++ b/src/mbgl/geometry/glyph_atlas.cpp @@ -140,6 +140,12 @@ void GlyphAtlas::removeGlyphs(uintptr_t tileUID) { } } +void GlyphAtlas::upload() { + if (dirty) { + bind(); + } +} + void GlyphAtlas::bind() { if (!texture) { MBGL_CHECK_ERROR(glGenTextures(1, &texture)); diff --git a/src/mbgl/geometry/glyph_atlas.hpp b/src/mbgl/geometry/glyph_atlas.hpp index a25c735a8..dfa568f0f 100644 --- a/src/mbgl/geometry/glyph_atlas.hpp +++ b/src/mbgl/geometry/glyph_atlas.hpp @@ -24,8 +24,13 @@ public: GlyphPositions&); void removeGlyphs(uintptr_t tileUID); + // Binds the atlas texture to the GPU, and uploads data if it is out of date. void bind(); + // Uploads the texture to the GPU to be available when we need it. This is a lazy operation; + // the texture is only bound when the data is out of date (=dirty). + void upload(); + const uint16_t width = 0; const uint16_t height = 0; diff --git a/src/mbgl/geometry/line_atlas.cpp b/src/mbgl/geometry/line_atlas.cpp index f64989d66..0dcaab2c4 100644 --- a/src/mbgl/geometry/line_atlas.cpp +++ b/src/mbgl/geometry/line_atlas.cpp @@ -129,6 +129,12 @@ LinePatternPos LineAtlas::addDash(const std::vector &dasharray, bool roun return position; }; +void LineAtlas::upload() { + if (dirty) { + bind(); + } +} + void LineAtlas::bind() { std::lock_guard lock(mtx); diff --git a/src/mbgl/geometry/line_atlas.hpp b/src/mbgl/geometry/line_atlas.hpp index df60a2dec..3683272f9 100644 --- a/src/mbgl/geometry/line_atlas.hpp +++ b/src/mbgl/geometry/line_atlas.hpp @@ -19,8 +19,13 @@ public: LineAtlas(uint16_t width, uint16_t height); ~LineAtlas(); + // Binds the atlas texture to the GPU, and uploads data if it is out of date. void bind(); + // Uploads the texture to the GPU to be available when we need it. This is a lazy operation; + // the texture is only bound when the data is out of date (=dirty). + void upload(); + LinePatternPos getDashPosition(const std::vector&, bool); LinePatternPos addDash(const std::vector &dasharray, bool round); diff --git a/src/mbgl/geometry/sprite_atlas.cpp b/src/mbgl/geometry/sprite_atlas.cpp index c2686e2f3..a6156febb 100644 --- a/src/mbgl/geometry/sprite_atlas.cpp +++ b/src/mbgl/geometry/sprite_atlas.cpp @@ -230,6 +230,12 @@ void SpriteAtlas::setSprite(util::ptr sprite_) { }); } +void SpriteAtlas::upload() { + if (dirty) { + bind(); + } +} + void SpriteAtlas::bind(bool linear) { bool first = false; if (!texture) { diff --git a/src/mbgl/geometry/sprite_atlas.hpp b/src/mbgl/geometry/sprite_atlas.hpp index 079c15cef..560514310 100644 --- a/src/mbgl/geometry/sprite_atlas.hpp +++ b/src/mbgl/geometry/sprite_atlas.hpp @@ -50,10 +50,13 @@ public: SpriteAtlasPosition getPosition(const std::string& name, bool repeating = false); - // Binds the image buffer of this sprite atlas to the GPU, and uploads data if it is out - // of date. + // Binds the atlas texture to the GPU, and uploads data if it is out of date. void bind(bool linear = false); + // Uploads the texture to the GPU to be available when we need it. This is a lazy operation; + // the texture is only bound when the data is out of date (=dirty). + void upload(); + inline float getWidth() const { return width; } inline float getHeight() const { return height; } inline float getTextureWidth() const { return width * pixelRatio; } diff --git a/src/mbgl/renderer/debug_bucket.cpp b/src/mbgl/renderer/debug_bucket.cpp index 7e367a95b..edd216571 100644 --- a/src/mbgl/renderer/debug_bucket.cpp +++ b/src/mbgl/renderer/debug_bucket.cpp @@ -17,6 +17,9 @@ DebugBucket::DebugBucket(DebugFontBuffer& fontBuffer_) } void DebugBucket::prepare() { + fontBuffer.upload(); + + renderPass = RenderPass::Translucent; } void DebugBucket::render(Painter& painter, const StyleLayer&, const TileID&, const mat4& matrix) { diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp index f8e604ee2..39163c863 100644 --- a/src/mbgl/renderer/fill_bucket.cpp +++ b/src/mbgl/renderer/fill_bucket.cpp @@ -201,6 +201,14 @@ void FillBucket::tessellate() { } void FillBucket::prepare() { + vertexBuffer.upload(); + triangleElementsBuffer.upload(); + lineElementsBuffer.upload(); + + // From now on, we're going to render during the opaque and translucent pass. + renderPass = static_cast( + static_cast::type>(RenderPass::Opaque) | + static_cast::type>(RenderPass::Translucent)); } void FillBucket::render(Painter& painter, diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp index 8e3a8ce9c..8ef5306d8 100644 --- a/src/mbgl/renderer/line_bucket.cpp +++ b/src/mbgl/renderer/line_bucket.cpp @@ -343,6 +343,11 @@ void LineBucket::addCurrentVertex(const Coordinate& currentVertex, } void LineBucket::prepare() { + vertexBuffer.upload(); + triangleElementsBuffer.upload(); + + // From now on, we're only going to render during the translucent pass. + renderPass = RenderPass::Translucent; } void LineBucket::render(Painter& painter, diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp index 74ad8b477..06f58f9c4 100644 --- a/src/mbgl/renderer/painter.cpp +++ b/src/mbgl/renderer/painter.cpp @@ -10,6 +10,8 @@ #include #include +#include +#include #include #include @@ -23,7 +25,6 @@ #include #include - #include #include #include @@ -210,10 +211,6 @@ void Painter::prepareTile(const Tile& tile) { void Painter::render(const Style& style, TransformState state_, TimePoint time) { state = state_; - clear(); - resize(); - changeMatrix(); - std::set sources; for (const auto& source : style.sources) { if (source->enabled) { @@ -221,6 +218,27 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) } } + // - PREPARATION PASS -------------------------------------------------------------------------- + // Uploads all required buffers and images before we do any actual rendering. + + // Figure out what buckets we have to draw and what order we have to draw them in. + const auto order = determineRenderOrder(style); + + tileStencilBuffer.upload(); + tileBorderBuffer.upload(); + spriteAtlas.upload(); + lineAtlas.upload(); + glyphAtlas.upload(); + + for (const auto& item : order) { + if (item.bucket && item.bucket->hasRenderPass(RenderPass::Prepare)) { + item.bucket->prepare(); + } + } + + // - CLIPPING MASKS ---------------------------------------------------------------------------- + // Draws the clipping masks to the stencil buffer. + // Update all clipping IDs. ClipIDGenerator generator; for (const auto& source : sources) { @@ -228,6 +246,10 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) source->updateMatrices(projMatrix, state); } + clear(); + resize(); + changeMatrix(); + drawClippingMasks(sources); frameHistory.record(time, state.getNormalizedZoom()); @@ -235,15 +257,12 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) // Actually render the layers if (debug::renderTree) { Log::Info(Event::Render, "{"); indent++; } - // Figure out what buckets we have to draw and what order we have to draw them in. - const auto order = determineRenderOrder(style); // TODO: Correctly compute the number of layers recursively beforehand. const float strata_thickness = 1.0f / (order.size() + 1); - // - FIRST PASS ------------------------------------------------------------ - // Render everything top-to-bottom by using reverse iterators. Render opaque - // objects first. + // - OPAQUE PASS ------------------------------------------------------------------------------- + // Render everything top-to-bottom by using reverse iterators. Render opaque objects first. if (debug::renderTree) { Log::Info(Event::Render, "%*s%s", indent++ * 4, "", "OPAQUE {"); @@ -253,9 +272,11 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) for (auto it = order.rbegin(), end = order.rend(); it != end; ++it, ++i) { const auto& item = *it; if (item.bucket && item.tile) { - setStrata(i * strata_thickness); - prepareTile(*item.tile); - item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix); + if (item.bucket->hasRenderPass(RenderPass::Opaque)) { + setStrata(i * strata_thickness); + prepareTile(*item.tile); + item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix); + } } else { renderBackground(item.layer); } @@ -264,9 +285,9 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) Log::Info(Event::Render, "%*s%s", --indent * 4, "", "}"); } - // - SECOND PASS ----------------------------------------------------------- - // Make a second pass, rendering translucent objects. This time, we render - // bottom-to-top. + // - TRANSLUCENT PASS -------------------------------------------------------------------------- + // Make a second pass, rendering translucent objects. This time, we render bottom-to-top. + if (debug::renderTree) { Log::Info(Event::Render, "%*s%s", indent++ * 4, "", "TRANSLUCENT {"); } @@ -275,9 +296,11 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) for (auto it = order.begin(), end = order.end(); it != end; ++it, --i) { const auto& item = *it; if (item.bucket && item.tile) { - setStrata(i * strata_thickness); - prepareTile(*item.tile); - item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix); + if (item.bucket->hasRenderPass(RenderPass::Translucent)) { + setStrata(i * strata_thickness); + prepareTile(*item.tile); + item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix); + } } } if (debug::renderTree) { @@ -293,6 +316,11 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) for (const auto& source : sources) { source->finishRender(*this); } + + // TODO: Find a better way to unbind VAOs after we're done with them without introducing + // unnecessary bind(0)/bind(N) sequences. + MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, 0)); + MBGL_CHECK_ERROR(gl::BindVertexArray(0)); } std::vector Painter::determineRenderOrder(const Style& style) { diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp index 7f1f92b5c..946d81749 100644 --- a/src/mbgl/renderer/raster_bucket.cpp +++ b/src/mbgl/renderer/raster_bucket.cpp @@ -14,6 +14,9 @@ RasterBucket::RasterBucket(TexturePool& texturePool, const StyleLayoutRaster& la } void RasterBucket::prepare() { + if (hasData()) { + raster.upload(); + } } void RasterBucket::render(Painter& painter, diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp index d520e4de2..62ede2840 100644 --- a/src/mbgl/renderer/symbol_bucket.cpp +++ b/src/mbgl/renderer/symbol_bucket.cpp @@ -37,6 +37,17 @@ SymbolBucket::~SymbolBucket() { } void SymbolBucket::prepare() { + if (hasTextData()) { + text.vertices.upload(); + text.triangles.upload(); + } + if (hasIconData()) { + icon.vertices.upload(); + icon.triangles.upload(); + } + + // From now on, we're going to render during the opaque and translucent pass. + renderPass = RenderPass::Translucent; } void SymbolBucket::render(Painter& painter, From c43016ce6c73c7305d259e7858efc0228d726660 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Thu, 23 Apr 2015 12:30:15 +0200 Subject: [PATCH 07/14] make sure we always to a full upload after sprite atlas resizes We always need to do a full upload to adjust the image buffer size when we adjust the size of our sprite atlas. This can happen when we change the pixelRatio of the map we're rendering. --- src/mbgl/geometry/sprite_atlas.cpp | 7 ++++--- src/mbgl/geometry/sprite_atlas.hpp | 1 + 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/mbgl/geometry/sprite_atlas.cpp b/src/mbgl/geometry/sprite_atlas.cpp index a6156febb..9d0aeac8b 100644 --- a/src/mbgl/geometry/sprite_atlas.cpp +++ b/src/mbgl/geometry/sprite_atlas.cpp @@ -58,6 +58,7 @@ bool SpriteAtlas::resize(const float newRatio) { ::operator delete(old_data); dirty = true; + fullUploadRequired = true; // Mark all sprite images as in need of update for (const auto &pair : images) { @@ -237,7 +238,6 @@ void SpriteAtlas::upload() { } void SpriteAtlas::bind(bool linear) { - bool first = false; if (!texture) { MBGL_CHECK_ERROR(glGenTextures(1, &texture)); MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture)); @@ -248,7 +248,7 @@ void SpriteAtlas::bind(bool linear) { // We use those when the pixelRatio isn't a power of two, e.g. on iPhone 6 Plus. MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); MBGL_CHECK_ERROR(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); - first = true; + fullUploadRequired = true; } else { MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture)); } @@ -264,7 +264,7 @@ void SpriteAtlas::bind(bool linear) { std::lock_guard lock(mtx); allocate(); - if (first) { + if (fullUploadRequired) { MBGL_CHECK_ERROR(glTexImage2D( GL_TEXTURE_2D, // GLenum target 0, // GLint level @@ -276,6 +276,7 @@ void SpriteAtlas::bind(bool linear) { GL_UNSIGNED_BYTE, // GLenum type data // const GLvoid * data )); + fullUploadRequired = false; } else { MBGL_CHECK_ERROR(glTexSubImage2D( GL_TEXTURE_2D, // GLenum target diff --git a/src/mbgl/geometry/sprite_atlas.hpp b/src/mbgl/geometry/sprite_atlas.hpp index 560514310..6c4a381aa 100644 --- a/src/mbgl/geometry/sprite_atlas.hpp +++ b/src/mbgl/geometry/sprite_atlas.hpp @@ -79,6 +79,7 @@ private: std::set uninitialized; uint32_t *data = nullptr; std::atomic dirty; + bool fullUploadRequired = true; uint32_t texture = 0; uint32_t filter = 0; static const int buffer = 1; From f89f7f1bc27e36467bab247f40bb823a3b7b178c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Thu, 23 Apr 2015 17:26:15 +0200 Subject: [PATCH 08/14] rename prepare => upload and determine passes per layer instead of per bucket --- src/mbgl/renderer/bucket.hpp | 16 ++++--------- src/mbgl/renderer/debug_bucket.cpp | 4 ++-- src/mbgl/renderer/debug_bucket.hpp | 2 +- src/mbgl/renderer/fill_bucket.cpp | 6 ++--- src/mbgl/renderer/fill_bucket.hpp | 2 +- src/mbgl/renderer/line_bucket.cpp | 4 ++-- src/mbgl/renderer/line_bucket.hpp | 2 +- src/mbgl/renderer/painter.cpp | 37 ++++++++++++++++++++++++----- src/mbgl/renderer/painter.hpp | 11 +++++++-- src/mbgl/renderer/raster_bucket.cpp | 3 ++- src/mbgl/renderer/raster_bucket.hpp | 2 +- src/mbgl/renderer/render_pass.hpp | 31 ++++++++++++++++++++++++ src/mbgl/renderer/symbol_bucket.cpp | 5 ++-- src/mbgl/renderer/symbol_bucket.hpp | 2 +- 14 files changed, 91 insertions(+), 36 deletions(-) create mode 100644 src/mbgl/renderer/render_pass.hpp diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp index 282a6aa36..36210f9cb 100644 --- a/src/mbgl/renderer/bucket.hpp +++ b/src/mbgl/renderer/bucket.hpp @@ -1,6 +1,7 @@ #ifndef MBGL_RENDERER_BUCKET #define MBGL_RENDERER_BUCKET +#include #include #include @@ -10,17 +11,11 @@ class Painter; class StyleLayer; class TileID; -enum class RenderPass : uint8_t { - Prepare = 1 << 0, - Opaque = 1 << 1, - Translucent = 1 << 2, -}; - class Bucket : private util::noncopyable { public: // As long as this bucket has a Prepare render pass, this function is getting called. Typically, // this only happens once when the bucket is being rendered for the first time. - virtual void prepare() = 0; + virtual void upload() = 0; // Every time this bucket is getting rendered, this function is called. This happens either // once or twice (for Opaque and Transparent render passes). @@ -28,13 +23,12 @@ public: virtual ~Bucket() {} - inline bool hasRenderPass(RenderPass pass) const { - return static_cast::type>(renderPass) & - static_cast::type>(pass); + inline bool needsUpload() const { + return uploaded; } protected: - RenderPass renderPass = RenderPass::Prepare; + bool uploaded = false; }; diff --git a/src/mbgl/renderer/debug_bucket.cpp b/src/mbgl/renderer/debug_bucket.cpp index edd216571..a315d089e 100644 --- a/src/mbgl/renderer/debug_bucket.cpp +++ b/src/mbgl/renderer/debug_bucket.cpp @@ -16,10 +16,10 @@ DebugBucket::DebugBucket(DebugFontBuffer& fontBuffer_) : fontBuffer(fontBuffer_) { } -void DebugBucket::prepare() { +void DebugBucket::upload() { fontBuffer.upload(); - renderPass = RenderPass::Translucent; + uploaded = true; } void DebugBucket::render(Painter& painter, const StyleLayer&, const TileID&, const mat4& matrix) { diff --git a/src/mbgl/renderer/debug_bucket.hpp b/src/mbgl/renderer/debug_bucket.hpp index 784530337..e3c01bbdd 100644 --- a/src/mbgl/renderer/debug_bucket.hpp +++ b/src/mbgl/renderer/debug_bucket.hpp @@ -15,7 +15,7 @@ class DebugBucket : public Bucket { public: DebugBucket(DebugFontBuffer& fontBuffer); - void prepare() override; + void upload() override; void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override; void drawLines(PlainShader& shader); diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp index 39163c863..c59b0970e 100644 --- a/src/mbgl/renderer/fill_bucket.cpp +++ b/src/mbgl/renderer/fill_bucket.cpp @@ -200,15 +200,13 @@ void FillBucket::tessellate() { lineGroup.vertex_length += total_vertex_count; } -void FillBucket::prepare() { +void FillBucket::upload() { vertexBuffer.upload(); triangleElementsBuffer.upload(); lineElementsBuffer.upload(); // From now on, we're going to render during the opaque and translucent pass. - renderPass = static_cast( - static_cast::type>(RenderPass::Opaque) | - static_cast::type>(RenderPass::Translucent)); + uploaded = true; } void FillBucket::render(Painter& painter, diff --git a/src/mbgl/renderer/fill_bucket.hpp b/src/mbgl/renderer/fill_bucket.hpp index 579b04acf..2ff86ba9a 100644 --- a/src/mbgl/renderer/fill_bucket.hpp +++ b/src/mbgl/renderer/fill_bucket.hpp @@ -33,7 +33,7 @@ public: LineElementsBuffer &lineElementsBuffer); ~FillBucket() override; - void prepare() override; + void upload() override; void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override; bool hasData() const; diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp index 8ef5306d8..651b4986e 100644 --- a/src/mbgl/renderer/line_bucket.cpp +++ b/src/mbgl/renderer/line_bucket.cpp @@ -342,12 +342,12 @@ void LineBucket::addCurrentVertex(const Coordinate& currentVertex, e2 = e3; } -void LineBucket::prepare() { +void LineBucket::upload() { vertexBuffer.upload(); triangleElementsBuffer.upload(); // From now on, we're only going to render during the translucent pass. - renderPass = RenderPass::Translucent; + uploaded = true; } void LineBucket::render(Painter& painter, diff --git a/src/mbgl/renderer/line_bucket.hpp b/src/mbgl/renderer/line_bucket.hpp index 9999fb637..6f13e3c81 100644 --- a/src/mbgl/renderer/line_bucket.hpp +++ b/src/mbgl/renderer/line_bucket.hpp @@ -28,7 +28,7 @@ public: LineBucket(LineVertexBuffer &vertexBuffer, TriangleElementsBuffer &triangleElementsBuffer); ~LineBucket() override; - void prepare() override; + void upload() override; void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override; bool hasData() const; diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp index 06f58f9c4..aea0a0229 100644 --- a/src/mbgl/renderer/painter.cpp +++ b/src/mbgl/renderer/painter.cpp @@ -218,7 +218,7 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) } } - // - PREPARATION PASS -------------------------------------------------------------------------- + // - UPLOAD PASS ------------------------------------------------------------------------------- // Uploads all required buffers and images before we do any actual rendering. // Figure out what buckets we have to draw and what order we have to draw them in. @@ -231,8 +231,8 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) glyphAtlas.upload(); for (const auto& item : order) { - if (item.bucket && item.bucket->hasRenderPass(RenderPass::Prepare)) { - item.bucket->prepare(); + if (item.bucket && item.bucket->needsUpload()) { + item.bucket->upload(); } } @@ -272,7 +272,7 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) for (auto it = order.rbegin(), end = order.rend(); it != end; ++it, ++i) { const auto& item = *it; if (item.bucket && item.tile) { - if (item.bucket->hasRenderPass(RenderPass::Opaque)) { + if (item.hasRenderPass(RenderPass::Opaque)) { setStrata(i * strata_thickness); prepareTile(*item.tile); item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix); @@ -296,7 +296,7 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) for (auto it = order.begin(), end = order.end(); it != end; ++it, --i) { const auto& item = *it; if (item.bucket && item.tile) { - if (item.bucket->hasRenderPass(RenderPass::Translucent)) { + if (item.hasRenderPass(RenderPass::Translucent)) { setStrata(i * strata_thickness); prepareTile(*item.tile); item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix); @@ -360,6 +360,9 @@ std::vector Painter::determineRenderOrder(const Style& style) { continue; } + // Determine what render passes we need for this layer. + const RenderPass passes = determineRenderPasses(layer); + const auto& tiles = layer.bucket->source->getTiles(); for (auto tile : tiles) { assert(tile); @@ -369,7 +372,7 @@ std::vector Painter::determineRenderOrder(const Style& style) { auto bucket = tile->data->getBucket(layer); if (bucket) { - order.emplace_back(layer, tile, bucket); + order.emplace_back(layer, tile, bucket, passes); } } } @@ -377,6 +380,28 @@ std::vector Painter::determineRenderOrder(const Style& style) { return order; } +RenderPass Painter::determineRenderPasses(const StyleLayer& layer) { + RenderPass passes = RenderPass::None; + + if (layer.properties.is()) { + const FillProperties &properties = layer.properties.get(); + const float alpha = properties.fill_color[3] * properties.opacity; + + if (properties.antialias) { + passes |= RenderPass::Translucent; + } + if (properties.image.from.size() || alpha < 1.0f) { + passes |= RenderPass::Translucent; + } else { + passes |= RenderPass::Opaque; + } + } else { + passes |= RenderPass::Translucent; + } + + return passes; +} + void Painter::renderBackground(const StyleLayer &layer_desc) { const BackgroundProperties& properties = layer_desc.getProperties(); diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp index 7010a933b..62c9f24da 100644 --- a/src/mbgl/renderer/painter.hpp +++ b/src/mbgl/renderer/painter.hpp @@ -59,13 +59,19 @@ struct ClipID; struct RenderItem { inline RenderItem(const StyleLayer& layer_, const Tile* tile_ = nullptr, - Bucket* bucket_ = nullptr) - : tile(tile_), bucket(bucket_), layer(layer_) { + Bucket* bucket_ = nullptr, + RenderPass passes_ = RenderPass::Opaque) + : tile(tile_), bucket(bucket_), layer(layer_), passes(passes_) { } const Tile* const tile; Bucket* const bucket; const StyleLayer& layer; + const RenderPass passes; + + inline bool hasRenderPass(RenderPass pass) const { + return bool(passes & pass); + } }; class Painter : private util::noncopyable { @@ -138,6 +144,7 @@ private: mat4 translatedMatrix(const mat4& matrix, const std::array &translation, const TileID &id, TranslateAnchorType anchor); std::vector determineRenderOrder(const Style& style); + static RenderPass determineRenderPasses(const StyleLayer&); void prepareTile(const Tile& tile); diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp index 946d81749..7ee64baaf 100644 --- a/src/mbgl/renderer/raster_bucket.cpp +++ b/src/mbgl/renderer/raster_bucket.cpp @@ -13,9 +13,10 @@ RasterBucket::RasterBucket(TexturePool& texturePool, const StyleLayoutRaster& la raster(texturePool) { } -void RasterBucket::prepare() { +void RasterBucket::upload() { if (hasData()) { raster.upload(); + uploaded = true; } } diff --git a/src/mbgl/renderer/raster_bucket.hpp b/src/mbgl/renderer/raster_bucket.hpp index 3faece546..70434b7d6 100644 --- a/src/mbgl/renderer/raster_bucket.hpp +++ b/src/mbgl/renderer/raster_bucket.hpp @@ -16,7 +16,7 @@ class RasterBucket : public Bucket { public: RasterBucket(TexturePool&, const StyleLayoutRaster&); - void prepare() override; + void upload() override; void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override; bool hasData() const; diff --git a/src/mbgl/renderer/render_pass.hpp b/src/mbgl/renderer/render_pass.hpp new file mode 100644 index 000000000..a298b8b57 --- /dev/null +++ b/src/mbgl/renderer/render_pass.hpp @@ -0,0 +1,31 @@ +#ifndef MBGL_RENDERER_RENDER_PASS +#define MBGL_RENDERER_RENDER_PASS + +#include +#include + +namespace mbgl { + +enum class RenderPass : uint8_t { + None = 0, + Opaque = 1 << 0, + Translucent = 1 << 1, +}; + +constexpr inline RenderPass operator|(RenderPass a, RenderPass b) { + return static_cast(static_cast::type>(a) | + static_cast::type>(b)); +} + +inline RenderPass operator|=(RenderPass& a, RenderPass b) { + return (a = a | b); +} + +constexpr inline RenderPass operator&(RenderPass a, RenderPass b) { + return static_cast(static_cast::type>(a) & + static_cast::type>(b)); +} + +} + +#endif diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp index 62ede2840..769feb67a 100644 --- a/src/mbgl/renderer/symbol_bucket.cpp +++ b/src/mbgl/renderer/symbol_bucket.cpp @@ -36,7 +36,7 @@ SymbolBucket::~SymbolBucket() { // Do not remove. header file only contains forward definitions to unique pointers. } -void SymbolBucket::prepare() { +void SymbolBucket::upload() { if (hasTextData()) { text.vertices.upload(); text.triangles.upload(); @@ -46,8 +46,7 @@ void SymbolBucket::prepare() { icon.triangles.upload(); } - // From now on, we're going to render during the opaque and translucent pass. - renderPass = RenderPass::Translucent; + uploaded = true; } void SymbolBucket::render(Painter& painter, diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp index 1c05150f4..b1dc44a11 100644 --- a/src/mbgl/renderer/symbol_bucket.hpp +++ b/src/mbgl/renderer/symbol_bucket.hpp @@ -55,7 +55,7 @@ public: SymbolBucket(Collision &collision); ~SymbolBucket() override; - void prepare() override; + void upload() override; void render(Painter&, const StyleLayer&, const TileID&, const mat4&) override; bool hasData() const; bool hasTextData() const; From 914b6f01f8a32fdc43e37e35b8fba69f3293ed33 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Thu, 23 Apr 2015 18:34:29 +0200 Subject: [PATCH 09/14] add gl::groups back for easier debugging in Xcode --- include/mbgl/platform/gl.hpp | 2 +- platform/ios/MGLMapView.mm | 6 ++ src/mbgl/renderer/painter.cpp | 156 ++++++++++++++++++++-------------- 3 files changed, 99 insertions(+), 65 deletions(-) diff --git a/include/mbgl/platform/gl.hpp b/include/mbgl/platform/gl.hpp index 61701a438..5c10f1610 100644 --- a/include/mbgl/platform/gl.hpp +++ b/include/mbgl/platform/gl.hpp @@ -159,7 +159,7 @@ inline void start_group(const std::string &str) { if (gl::PushDebugGroup != nullptr) { MBGL_CHECK_ERROR(gl::PushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, 0, GLsizei(str.size()), str.c_str())); } else if (gl::PushGroupMarkerEXT != nullptr) { - MBGL_CHECK_ERROR(gl::PushGroupMarkerEXT(GLsizei(str.size()), str.c_str())); + MBGL_CHECK_ERROR(gl::PushGroupMarkerEXT(GLsizei(str.size() + 1), str.c_str())); } // fprintf(stderr, "%s%s\n", std::string(indent * 4, ' ').c_str(), str.c_str()); // indent++; diff --git a/platform/ios/MGLMapView.mm b/platform/ios/MGLMapView.mm index 99fc55e7e..fd448b899 100644 --- a/platform/ios/MGLMapView.mm +++ b/platform/ios/MGLMapView.mm @@ -249,6 +249,12 @@ std::chrono::steady_clock::duration secondsAsDuration(float duration) gl::IsVertexArray = glIsVertexArrayOES; } + if (extensions.find("GL_EXT_debug_marker") != std::string::npos) { + gl::InsertEventMarkerEXT = glInsertEventMarkerEXT; + gl::PushGroupMarkerEXT = glPushGroupMarkerEXT; + gl::PopGroupMarkerEXT = glPopGroupMarkerEXT; + } + if (extensions.find("GL_OES_packed_depth_stencil") != std::string::npos) { gl::isPackedDepthStencilSupported = YES; } diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp index aea0a0229..8f0634dee 100644 --- a/src/mbgl/renderer/painter.cpp +++ b/src/mbgl/renderer/painter.cpp @@ -218,109 +218,137 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time) } } - // - UPLOAD PASS ------------------------------------------------------------------------------- - // Uploads all required buffers and images before we do any actual rendering. - // Figure out what buckets we have to draw and what order we have to draw them in. const auto order = determineRenderOrder(style); - tileStencilBuffer.upload(); - tileBorderBuffer.upload(); - spriteAtlas.upload(); - lineAtlas.upload(); - glyphAtlas.upload(); + // - UPLOAD PASS ------------------------------------------------------------------------------- + // Uploads all required buffers and images before we do any actual rendering. + { + const gl::group upload("upload"); - for (const auto& item : order) { - if (item.bucket && item.bucket->needsUpload()) { - item.bucket->upload(); + tileStencilBuffer.upload(); + tileBorderBuffer.upload(); + spriteAtlas.upload(); + lineAtlas.upload(); + glyphAtlas.upload(); + + for (const auto& item : order) { + if (item.bucket && item.bucket->needsUpload()) { + item.bucket->upload(); + } } } + // - CLIPPING MASKS ---------------------------------------------------------------------------- // Draws the clipping masks to the stencil buffer. + { + const gl::group clip("clip"); - // Update all clipping IDs. - ClipIDGenerator generator; - for (const auto& source : sources) { - generator.update(source->getLoadedTiles()); - source->updateMatrices(projMatrix, state); + // Update all clipping IDs. + ClipIDGenerator generator; + for (const auto& source : sources) { + generator.update(source->getLoadedTiles()); + source->updateMatrices(projMatrix, state); + } + + clear(); + resize(); + changeMatrix(); + + drawClippingMasks(sources); } - clear(); - resize(); - changeMatrix(); - - drawClippingMasks(sources); - frameHistory.record(time, state.getNormalizedZoom()); // Actually render the layers if (debug::renderTree) { Log::Info(Event::Render, "{"); indent++; } - // TODO: Correctly compute the number of layers recursively beforehand. const float strata_thickness = 1.0f / (order.size() + 1); + // Layer index + int i = 0; + // - OPAQUE PASS ------------------------------------------------------------------------------- // Render everything top-to-bottom by using reverse iterators. Render opaque objects first. + { + const gl::group _("opaque"); - if (debug::renderTree) { - Log::Info(Event::Render, "%*s%s", indent++ * 4, "", "OPAQUE {"); - } - int i = 0; - setOpaque(); - for (auto it = order.rbegin(), end = order.rend(); it != end; ++it, ++i) { - const auto& item = *it; - if (item.bucket && item.tile) { - if (item.hasRenderPass(RenderPass::Opaque)) { - setStrata(i * strata_thickness); - prepareTile(*item.tile); - item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix); - } - } else { - renderBackground(item.layer); + if (debug::renderTree) { + Log::Info(Event::Render, "%*s%s", indent++ * 4, "", "OPAQUE {"); + } + i = 0; + setOpaque(); + for (auto it = order.rbegin(), end = order.rend(); it != end; ++it, ++i) { + const auto& item = *it; + if (item.bucket && item.tile) { + if (item.hasRenderPass(RenderPass::Opaque)) { + const gl::group group(item.layer.id + " - " + std::string(item.tile->id)); + setStrata(i * strata_thickness); + prepareTile(*item.tile); + item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix); + } + } else { + const gl::group group("background"); + renderBackground(item.layer); + } + } + if (debug::renderTree) { + Log::Info(Event::Render, "%*s%s", --indent * 4, "", "}"); } - } - if (debug::renderTree) { - Log::Info(Event::Render, "%*s%s", --indent * 4, "", "}"); } // - TRANSLUCENT PASS -------------------------------------------------------------------------- // Make a second pass, rendering translucent objects. This time, we render bottom-to-top. + { + const gl::group _("translucent"); - if (debug::renderTree) { - Log::Info(Event::Render, "%*s%s", indent++ * 4, "", "TRANSLUCENT {"); - } - --i; - setTranslucent(); - for (auto it = order.begin(), end = order.end(); it != end; ++it, --i) { - const auto& item = *it; - if (item.bucket && item.tile) { - if (item.hasRenderPass(RenderPass::Translucent)) { - setStrata(i * strata_thickness); - prepareTile(*item.tile); - item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix); + if (debug::renderTree) { + Log::Info(Event::Render, "%*s%s", indent++ * 4, "", "TRANSLUCENT {"); + } + --i; // After the last iteration, this is incremented, so we have to decrement it again. + setTranslucent(); + for (auto it = order.begin(), end = order.end(); it != end; ++it, --i) { + const auto& item = *it; + if (item.bucket && item.tile) { + if (item.hasRenderPass(RenderPass::Translucent)) { + const gl::group group(item.layer.id + " - " + std::string(item.tile->id)); + setStrata(i * strata_thickness); + prepareTile(*item.tile); + item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix); + } } } - } - if (debug::renderTree) { - Log::Info(Event::Render, "%*s%s", --indent * 4, "", "}"); + if (debug::renderTree) { + Log::Info(Event::Render, "%*s%s", --indent * 4, "", "}"); + } } if (debug::renderTree) { Log::Info(Event::Render, "}"); indent--; } - // Finalize the rendering, e.g. by calling debug render calls per tile. - // This guarantees that we have at least one function per tile called. - // When only rendering layers via the stylesheet, it's possible that we don't - // ever visit a tile during rendering. - for (const auto& source : sources) { - source->finishRender(*this); + // - DEBUG PASS -------------------------------------------------------------------------------- + // Renders debug overlays. + { + const gl::group _("debug"); + + // Finalize the rendering, e.g. by calling debug render calls per tile. + // This guarantees that we have at least one function per tile called. + // When only rendering layers via the stylesheet, it's possible that we don't + // ever visit a tile during rendering. + for (const auto& source : sources) { + source->finishRender(*this); + } } // TODO: Find a better way to unbind VAOs after we're done with them without introducing // unnecessary bind(0)/bind(N) sequences. - MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, 0)); - MBGL_CHECK_ERROR(gl::BindVertexArray(0)); + { + const gl::group _("cleanup"); + + MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, 0)); + MBGL_CHECK_ERROR(gl::BindVertexArray(0)); + } } std::vector Painter::determineRenderOrder(const Style& style) { From 72964f5bef1ed9210618ab3b02dc92c0d1cbf92c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Mon, 27 Apr 2015 17:53:05 +0200 Subject: [PATCH 10/14] only update GL state when it actually changed --- include/mbgl/util/gl_helper.hpp | 87 +++++++++++++++ platform/default/glfw_view.cpp | 36 ++++-- src/mbgl/renderer/gl_config.cpp | 19 ++++ src/mbgl/renderer/gl_config.hpp | 149 +++++++++++++++++++++++++ src/mbgl/renderer/painter.cpp | 45 +++----- src/mbgl/renderer/painter.hpp | 8 +- src/mbgl/renderer/painter_clipping.cpp | 22 ++-- src/mbgl/renderer/painter_debug.cpp | 16 ++- src/mbgl/renderer/painter_fill.cpp | 15 ++- src/mbgl/renderer/painter_line.cpp | 8 +- src/mbgl/renderer/painter_raster.cpp | 5 +- src/mbgl/renderer/painter_symbol.cpp | 13 +-- 12 files changed, 340 insertions(+), 83 deletions(-) create mode 100644 include/mbgl/util/gl_helper.hpp create mode 100644 src/mbgl/renderer/gl_config.cpp create mode 100644 src/mbgl/renderer/gl_config.hpp diff --git a/include/mbgl/util/gl_helper.hpp b/include/mbgl/util/gl_helper.hpp new file mode 100644 index 000000000..cf007e8a6 --- /dev/null +++ b/include/mbgl/util/gl_helper.hpp @@ -0,0 +1,87 @@ +#ifndef MBGL_UTIL_GL_HELPER +#define MBGL_UTIL_GL_HELPER + +#include + +#include + +namespace { + +template +class Preserve { +public: + Preserve() : data(Create()) {} + ~Preserve() { Destroy(data); } + +private: + const T data; +}; + +inline bool getBlend() { + return glIsEnabled(GL_BLEND); +} + +inline void setBlend(const bool& enabled) { + enabled ? MBGL_CHECK_ERROR(glEnable(GL_BLEND)) : MBGL_CHECK_ERROR(glDisable(GL_BLEND)); +} + +inline std::array getClearColor() { + std::array color; + MBGL_CHECK_ERROR(glGetDoublev(GL_COLOR_CLEAR_VALUE, color.data())); + return color; +} + +inline void setClearColor(const std::array& color) { + MBGL_CHECK_ERROR(glClearColor(color[0], color[1], color[2], color[3])); +} + + +inline std::array getBlendFunc() { + GLint func[2]; + glGetIntegerv(GL_BLEND_SRC, &func[0]); + glGetIntegerv(GL_BLEND_DST, &func[1]); + return {{ static_cast(func[0]), static_cast(func[1]) }}; +} + +inline void setBlendFunc(const std::array& func) { + MBGL_CHECK_ERROR(glBlendFunc(func[0], func[1])); +} + + +inline std::array getPixelZoom() { + std::array zoom; + glGetDoublev(GL_ZOOM_X, &zoom[0]); + glGetDoublev(GL_ZOOM_Y, &zoom[1]); + return zoom; +} + +inline void setPixelZoom(const std::array& func) { + MBGL_CHECK_ERROR(glPixelZoom(func[0], func[1])); +} + + +inline std::array getRasterPos() { + std::array pos; + MBGL_CHECK_ERROR(glGetDoublev(GL_CURRENT_RASTER_POSITION, pos.data())); + return pos; +} + +inline void setRasterPos(const std::array& pos) { + MBGL_CHECK_ERROR(glRasterPos4d(pos[0], pos[1], pos[2], pos[3])); +} + +} // end anonymous namespace + +namespace mbgl { +namespace gl { + +using PreserveBlend = Preserve; +using PreserveClearColor = Preserve, getClearColor, setClearColor>; +using PreserveBlendFunc = Preserve, getBlendFunc, setBlendFunc>; +using PreservePixelZoom = Preserve, getPixelZoom, setPixelZoom>; +using PreserveRasterPos = Preserve, getRasterPos, setRasterPos>; + +} +} + +#endif diff --git a/platform/default/glfw_view.cpp b/platform/default/glfw_view.cpp index 84de908db..56aeaf30a 100644 --- a/platform/default/glfw_view.cpp +++ b/platform/default/glfw_view.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include @@ -333,15 +334,20 @@ void showDebugImage(std::string name, const char *data, size_t width, size_t hei glfwGetFramebufferSize(debugWindow, &fbWidth, &fbHeight); float scale = static_cast(fbWidth) / static_cast(width); - MBGL_CHECK_ERROR(glPixelZoom(scale, -scale)); - MBGL_CHECK_ERROR(glRasterPos2f(-1.0f, 1.0f)); - MBGL_CHECK_ERROR(glDrawPixels(width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, data)); + { + gl::PreservePixelZoom pixelZoom; + gl::PreserveRasterPos rasterPos; + + MBGL_CHECK_ERROR(glPixelZoom(scale, -scale)); + MBGL_CHECK_ERROR(glRasterPos2f(-1.0f, 1.0f)); + MBGL_CHECK_ERROR(glDrawPixels(width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, data)); + } + glfwSwapBuffers(debugWindow); glfwMakeContextCurrent(currentWindow); } - void showColorDebugImage(std::string name, const char *data, size_t logicalWidth, size_t logicalHeight, size_t width, size_t height) { glfwInit(); @@ -365,14 +371,22 @@ void showColorDebugImage(std::string name, const char *data, size_t logicalWidth float xScale = static_cast(fbWidth) / static_cast(width); float yScale = static_cast(fbHeight) / static_cast(height); - MBGL_CHECK_ERROR(glClearColor(0.8, 0.8, 0.8, 1)); - MBGL_CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT)); - MBGL_CHECK_ERROR(glEnable(GL_BLEND)); - MBGL_CHECK_ERROR(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)); + { + gl::PreserveClearColor clearColor; + gl::PreserveBlend blend; + gl::PreserveBlendFunc blendFunc; + gl::PreservePixelZoom pixelZoom; + gl::PreserveRasterPos rasterPos; + + MBGL_CHECK_ERROR(glClearColor(0.8, 0.8, 0.8, 1)); + MBGL_CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT)); + MBGL_CHECK_ERROR(glEnable(GL_BLEND)); + MBGL_CHECK_ERROR(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)); + MBGL_CHECK_ERROR(glPixelZoom(xScale, -yScale)); + MBGL_CHECK_ERROR(glRasterPos2f(-1.0f, 1.0f)); + MBGL_CHECK_ERROR(glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, data)); + } - MBGL_CHECK_ERROR(glPixelZoom(xScale, -yScale)); - MBGL_CHECK_ERROR(glRasterPos2f(-1.0f, 1.0f)); - MBGL_CHECK_ERROR(glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, data)); glfwSwapBuffers(debugWindow); glfwMakeContextCurrent(currentWindow); diff --git a/src/mbgl/renderer/gl_config.cpp b/src/mbgl/renderer/gl_config.cpp new file mode 100644 index 000000000..ae648d4d3 --- /dev/null +++ b/src/mbgl/renderer/gl_config.cpp @@ -0,0 +1,19 @@ +#include "gl_config.hpp" + +namespace mbgl { +namespace gl { + +const ClearDepth::Type ClearDepth::Default = 0; +const ClearColor::Type ClearColor::Default = { 0, 0, 0, 0 }; +const ClearStencil::Type ClearStencil::Default = 0; +const StencilMask::Type StencilMask::Default = ~0u; +const DepthMask::Type DepthMask::Default = GL_TRUE; +const ColorMask::Type ColorMask::Default = { false, false, false, false }; +const StencilFunc::Type StencilFunc::Default = { GL_ALWAYS, 0, ~0u }; +const StencilTest::Type StencilTest::Default = false; +const DepthRange::Type DepthRange::Default = { 0, 1 }; +const DepthTest::Type DepthTest::Default = false; +const Blend::Type Blend::Default = false; + +} +} diff --git a/src/mbgl/renderer/gl_config.hpp b/src/mbgl/renderer/gl_config.hpp new file mode 100644 index 000000000..59507f721 --- /dev/null +++ b/src/mbgl/renderer/gl_config.hpp @@ -0,0 +1,149 @@ +#ifndef MBGL_RENDERER_GL_CONFIG +#define MBGL_RENDERER_GL_CONFIG + +#include +#include +#include + +#include + +namespace mbgl { +namespace gl { + +template +class Value { +public: + inline void operator=(const typename T::Type& value) { + if (current != value) { + current = value; + MBGL_CHECK_ERROR(T::Set(current)); + } + } + +private: + typename T::Type current = T::Default; +}; + +struct ClearDepth { + using Type = GLfloat; + static const Type Default; + inline static void Set(const Type& value) { + MBGL_CHECK_ERROR(glClearDepth(value)); + } +}; + +struct ClearColor { + struct Type { float r, g, b, a; }; + static const Type Default; + inline static void Set(const Type& value) { + MBGL_CHECK_ERROR(glClearColor(value.r, value.g, value.b, value.a)); + } +}; + +inline bool operator!=(const ClearColor::Type& a, const ClearColor::Type& b) { + return a.r != b.r || a.g != b.g || a.b != b.b || a.a != b.a; +} + +struct ClearStencil { + using Type = GLint; + static const Type Default; + inline static void Set(const Type& value) { + MBGL_CHECK_ERROR(glClearStencil(value)); + } +}; + +struct StencilMask { + using Type = GLuint; + static const Type Default; + inline static void Set(const Type& value) { + MBGL_CHECK_ERROR(glStencilMask(value)); + } +}; + +struct DepthMask { + using Type = GLboolean; + static const Type Default; + inline static void Set(const Type& value) { + MBGL_CHECK_ERROR(glDepthMask(value)); + } +}; + +struct ColorMask { + struct Type { bool r, g, b, a; }; + static const Type Default; + inline static void Set(const Type& value) { + MBGL_CHECK_ERROR(glColorMask(value.r, value.g, value.b, value.a)); + } +}; + +inline bool operator!=(const ColorMask::Type& a, const ColorMask::Type& b) { + return a.r != b.r || a.g != b.g || a.b != b.b || a.a != b.a; +} + +struct StencilFunc { + struct Type { GLenum func; GLint ref; GLuint mask; }; + static const Type Default; + inline static void Set(const Type& value) { + MBGL_CHECK_ERROR(glStencilFunc(value.func, value.ref, value.mask)); + } +}; + +inline bool operator!=(const StencilFunc::Type& a, const StencilFunc::Type& b) { + return a.func != b.func || a.ref != b.ref || a.mask != b.mask; +} + +struct StencilTest { + using Type = bool; + static const Type Default; + inline static void Set(const Type& value) { + MBGL_CHECK_ERROR(value ? glEnable(GL_STENCIL_TEST) : glDisable(GL_STENCIL_TEST)); + } +}; + +struct DepthRange { + struct Type { GLfloat near, far; }; + static const Type Default; + inline static void Set(const Type& value) { + MBGL_CHECK_ERROR(glDepthRange(value.near, value.far)); + } +}; + +inline bool operator!=(const DepthRange::Type& a, const DepthRange::Type& b) { + return a.near != b.near || a.far != b.far; +} + +struct DepthTest { + using Type = bool; + static const Type Default; + inline static void Set(const Type& value) { + MBGL_CHECK_ERROR(value ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST)); + } +}; + +struct Blend { + using Type = bool; + static const Type Default; + inline static void Set(const Type& value) { + MBGL_CHECK_ERROR(value ? glEnable(GL_BLEND) : glDisable(GL_BLEND)); + } +}; + +class Config { +public: + Value stencilFunc; + Value stencilMask; + Value stencilTest; + Value depthRange; + Value depthMask; + Value depthTest; + Value blend; + Value colorMask; + Value clearDepth; + Value clearColor; + Value clearStencil; +}; + +} +} + +#endif diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp index 8f0634dee..a80fd4e8b 100644 --- a/src/mbgl/renderer/painter.cpp +++ b/src/mbgl/renderer/painter.cpp @@ -88,16 +88,15 @@ 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. - MBGL_CHECK_ERROR(glEnable(GL_BLEND)); + config.blend = true; MBGL_CHECK_ERROR(glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA)); // Set clear values - MBGL_CHECK_ERROR(glClearColor(0.0f, 0.0f, 0.0f, 0.0f)); - MBGL_CHECK_ERROR(glClearDepth(1.0f)); - MBGL_CHECK_ERROR(glClearStencil(0x0)); + config.clearColor = { 0.0f, 0.0f, 0.0f, 0.0f }; + config.clearDepth = 1.0f; + config.clearStencil = 0x0; // Stencil test - MBGL_CHECK_ERROR(glEnable(GL_STENCIL_TEST)); MBGL_CHECK_ERROR(glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE)); // Depth test @@ -145,21 +144,6 @@ void Painter::lineWidth(float line_width) { } } -void Painter::depthMask(bool value) { - if (gl_depthMask != value) { - MBGL_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) { - MBGL_CHECK_ERROR(glDepthRange(near, far)); - gl_depthRange = {{ near, far }}; - } -} - - void Painter::changeMatrix() { // Initialize projection matrix matrix::ortho(projMatrix, 0, state.getWidth(), state.getHeight(), 0, 0, 1); @@ -177,24 +161,25 @@ void Painter::changeMatrix() { void Painter::clear() { gl::group group("clear"); - MBGL_CHECK_ERROR(glStencilMask(0xFF)); - depthMask(true); - - MBGL_CHECK_ERROR(glClearColor(0, 0, 0, 0)); + config.stencilTest = true; + config.stencilMask = 0xFF; + config.depthTest = false; + config.depthMask = GL_TRUE; + config.clearColor = { 0.0f, 0.0f, 0.0f, 0.0f }; MBGL_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; - MBGL_CHECK_ERROR(glDisable(GL_BLEND)); + config.blend = false; } } void Painter::setTranslucent() { if (pass != RenderPass::Translucent) { pass = RenderPass::Translucent; - MBGL_CHECK_ERROR(glEnable(GL_BLEND)); + config.blend = true; } } @@ -205,7 +190,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(); - MBGL_CHECK_ERROR(glStencilFunc(GL_EQUAL, ref, mask)); + config.stencilFunc = { GL_EQUAL, ref, mask }; } void Painter::render(const Style& style, TransformState state_, TimePoint time) { @@ -504,10 +489,10 @@ void Painter::renderBackground(const StyleLayer &layer_desc) { backgroundArray.bind(*plainShader, backgroundBuffer, BUFFER_OFFSET(0)); } - MBGL_CHECK_ERROR(glDisable(GL_STENCIL_TEST)); - depthRange(strata + strata_epsilon, 1.0f); + config.stencilTest = false; + config.depthTest = true; + config.depthRange = { strata + strata_epsilon, 1.0f }; MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)); - MBGL_CHECK_ERROR(glEnable(GL_STENCIL_TEST)); } mat4 Painter::translatedMatrix(const mat4& matrix, const std::array &translation, const TileID &id, TranslateAnchorType anchor) { diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp index 62c9f24da..54c23b393 100644 --- a/src/mbgl/renderer/painter.hpp +++ b/src/mbgl/renderer/painter.hpp @@ -9,6 +9,8 @@ #include #include +#include + #include #include @@ -162,8 +164,6 @@ private: public: void useProgram(uint32_t program); void lineWidth(float lineWidth); - void depthMask(bool value); - void depthRange(float near, float far); public: mat4 projMatrix; @@ -190,11 +190,11 @@ private: bool debug = false; int indent = 0; + gl::Config config; + uint32_t gl_program = 0; float gl_lineWidth = 0; - bool gl_depthMask = true; std::array gl_viewport = {{ 0, 0 }}; - std::array gl_depthRange = {{ 0, 1 }}; float strata = 0; RenderPass pass = RenderPass::Opaque; const float strata_epsilon = 1.0f / (1 << 16); diff --git a/src/mbgl/renderer/painter_clipping.cpp b/src/mbgl/renderer/painter_clipping.cpp index a8542b44c..c49535928 100644 --- a/src/mbgl/renderer/painter_clipping.cpp +++ b/src/mbgl/renderer/painter_clipping.cpp @@ -13,10 +13,11 @@ void Painter::drawClippingMasks(const std::set& sources) { gl::group group("clipping masks"); useProgram(plainShader->program); - MBGL_CHECK_ERROR(glDisable(GL_DEPTH_TEST)); - depthMask(false); - MBGL_CHECK_ERROR(glColorMask(false, false, false, false)); - depthRange(1.0f, 1.0f); + config.stencilTest = true; + config.depthTest = true; + config.depthMask = GL_FALSE; + config.colorMask = { false, false, false, false }; + config.depthRange = { 1.0f, 1.0f }; coveringPlainArray.bind(*plainShader, tileStencilBuffer, BUFFER_OFFSET(0)); @@ -24,10 +25,10 @@ void Painter::drawClippingMasks(const std::set& sources) { source->drawClippingMasks(*this); } - MBGL_CHECK_ERROR(glEnable(GL_DEPTH_TEST)); - MBGL_CHECK_ERROR(glColorMask(true, true, true, true)); - depthMask(true); - MBGL_CHECK_ERROR(glStencilMask(0x0)); + config.depthTest = true; + config.colorMask = { true, true, true, true }; + config.depthMask = GL_TRUE; + config.stencilMask = 0x0; } void Painter::drawClippingMask(const mat4& matrix, const ClipID &clip) { @@ -35,8 +36,7 @@ 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()); - MBGL_CHECK_ERROR(glStencilFunc(GL_ALWAYS, ref, mask)); - MBGL_CHECK_ERROR(glStencilMask(mask)); - + config.stencilFunc = { GL_ALWAYS, ref, mask }; + config.stencilMask = mask; MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index())); } diff --git a/src/mbgl/renderer/painter_debug.cpp b/src/mbgl/renderer/painter_debug.cpp index 457c1e5da..b252e2e83 100644 --- a/src/mbgl/renderer/painter_debug.cpp +++ b/src/mbgl/renderer/painter_debug.cpp @@ -24,7 +24,7 @@ void Painter::renderTileDebug(const Tile& tile) { void Painter::renderDebugText(DebugBucket& bucket, const mat4 &matrix) { gl::group group("debug text"); - MBGL_CHECK_ERROR(glDisable(GL_DEPTH_TEST)); + config.depthTest = false; useProgram(plainShader->program); plainShader->u_matrix = matrix; @@ -45,7 +45,7 @@ void Painter::renderDebugText(DebugBucket& bucket, const mat4 &matrix) { lineWidth(2.0f * state.getPixelRatio()); bucket.drawLines(*plainShader); - MBGL_CHECK_ERROR(glEnable(GL_DEPTH_TEST)); + config.depthTest = true; } void Painter::renderDebugFrame(const mat4 &matrix) { @@ -54,7 +54,8 @@ 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. - MBGL_CHECK_ERROR(glDisable(GL_DEPTH_TEST)); + config.depthTest = false; + config.stencilTest = true; useProgram(plainShader->program); plainShader->u_matrix = matrix; @@ -64,8 +65,6 @@ void Painter::renderDebugFrame(const mat4 &matrix) { plainShader->u_color = {{ 1.0f, 0.0f, 0.0f, 1.0f }}; lineWidth(4.0f * state.getPixelRatio()); MBGL_CHECK_ERROR(glDrawArrays(GL_LINE_STRIP, 0, (GLsizei)tileBorderBuffer.index())); - - MBGL_CHECK_ERROR(glEnable(GL_DEPTH_TEST)); } void Painter::renderDebugText(const std::vector &strings) { @@ -75,8 +74,9 @@ void Painter::renderDebugText(const std::vector &strings) { gl::group group("debug text"); - MBGL_CHECK_ERROR(glDisable(GL_DEPTH_TEST)); - MBGL_CHECK_ERROR(glStencilFunc(GL_ALWAYS, 0xFF, 0xFF)); + config.depthTest = false; + config.stencilTest = true; + config.stencilFunc = { GL_ALWAYS, 0xFF, 0xFF }; useProgram(plainShader->program); plainShader->u_matrix = nativeMatrix; @@ -103,6 +103,4 @@ void Painter::renderDebugText(const std::vector &strings) { lineWidth(2.0f * state.getPixelRatio()); MBGL_CHECK_ERROR(glDrawArrays(GL_LINES, 0, (GLsizei)debugFontBuffer.index())); } - - MBGL_CHECK_ERROR(glEnable(GL_DEPTH_TEST)); } diff --git a/src/mbgl/renderer/painter_fill.cpp b/src/mbgl/renderer/painter_fill.cpp index 1c5dd88b9..6f6783f0e 100644 --- a/src/mbgl/renderer/painter_fill.cpp +++ b/src/mbgl/renderer/painter_fill.cpp @@ -39,6 +39,9 @@ void Painter::renderFill(FillBucket& bucket, const StyleLayer &layer_desc, const bool outline = properties.antialias && !pattern && stroke_color != fill_color; bool fringeline = properties.antialias && !pattern && stroke_color == fill_color; + config.stencilTest = true; + config.depthTest = true; + // Because we're drawing top-to-bottom, and we update the stencil mask // befrom, we have to draw the outline first (!) if (outline && pass == RenderPass::Translucent) { @@ -53,7 +56,7 @@ void Painter::renderFill(FillBucket& bucket, const StyleLayer &layer_desc, const static_cast(state.getFramebufferWidth()), static_cast(state.getFramebufferHeight()) }}; - depthRange(strata, 1.0f); + config.depthRange = { strata, 1.0f }; bucket.drawVertices(*outlineShader); } @@ -92,8 +95,8 @@ void Painter::renderFill(FillBucket& bucket, const StyleLayer &layer_desc, const spriteAtlas.bind(true); // Draw the actual triangles into the color & stencil buffer. - depthMask(true); - depthRange(strata, 1.0f); + config.depthMask = GL_TRUE; + config.depthRange = { strata, 1.0f }; bucket.drawElements(*patternShader); } } @@ -109,8 +112,8 @@ void Painter::renderFill(FillBucket& bucket, const StyleLayer &layer_desc, const plainShader->u_color = fill_color; // Draw the actual triangles into the color & stencil buffer. - depthMask(true); - depthRange(strata + strata_epsilon, 1.0f); + config.depthMask = GL_TRUE; + config.depthRange = { strata + strata_epsilon, 1.0f }; bucket.drawElements(*plainShader); } } @@ -130,7 +133,7 @@ void Painter::renderFill(FillBucket& bucket, const StyleLayer &layer_desc, const static_cast(state.getFramebufferHeight()) }}; - depthRange(strata + strata_epsilon + strata_epsilon, 1.0f); + config.depthRange = { strata + strata_epsilon + strata_epsilon, 1.0f }; bucket.drawVertices(*outlineShader); } } diff --git a/src/mbgl/renderer/painter_line.cpp b/src/mbgl/renderer/painter_line.cpp index 929ba5c5d..f552ea6c4 100644 --- a/src/mbgl/renderer/painter_line.cpp +++ b/src/mbgl/renderer/painter_line.cpp @@ -17,7 +17,9 @@ void Painter::renderLine(LineBucket& bucket, const StyleLayer &layer_desc, const // Abort early. if (pass == RenderPass::Opaque) return; - depthMask(false); + config.stencilTest = true; + config.depthTest = true; + config.depthMask = GL_FALSE; const auto &properties = layer_desc.getProperties(); const auto &layout = bucket.layout; @@ -51,7 +53,7 @@ void Painter::renderLine(LineBucket& bucket, const StyleLayer &layer_desc, const float ratio = state.getPixelRatio(); mat4 vtxMatrix = translatedMatrix(matrix, properties.translate, id, properties.translateAnchor); - depthRange(strata, 1.0f); + config.depthRange = { strata, 1.0f }; if (properties.dash_array.from.size()) { @@ -109,7 +111,7 @@ void Painter::renderLine(LineBucket& bucket, const StyleLayer &layer_desc, const MBGL_CHECK_ERROR(glActiveTexture(GL_TEXTURE0)); spriteAtlas.bind(true); - MBGL_CHECK_ERROR(glDepthRange(strata + strata_epsilon, 1.0f)); // may or may not matter + config.depthRange = { strata + strata_epsilon, 1.0f }; // may or may not matter bucket.drawLinePatterns(*linepatternShader); diff --git a/src/mbgl/renderer/painter_raster.cpp b/src/mbgl/renderer/painter_raster.cpp index 513c613cb..61aff9c1a 100644 --- a/src/mbgl/renderer/painter_raster.cpp +++ b/src/mbgl/renderer/painter_raster.cpp @@ -23,8 +23,9 @@ void Painter::renderRaster(RasterBucket& bucket, const StyleLayer &layer_desc, c rasterShader->u_contrast_factor = contrastFactor(properties.contrast); rasterShader->u_spin_weights = spinWeights(properties.hue_rotate); - depthRange(strata + strata_epsilon, 1.0f); - + config.stencilTest = true; + config.depthTest = true; + config.depthRange = { strata + strata_epsilon, 1.0f }; bucket.drawRaster(*rasterShader, tileStencilBuffer, coveringRasterArray); } } diff --git a/src/mbgl/renderer/painter_symbol.cpp b/src/mbgl/renderer/painter_symbol.cpp index db3985c30..1841f2bc9 100644 --- a/src/mbgl/renderer/painter_symbol.cpp +++ b/src/mbgl/renderer/painter_symbol.cpp @@ -87,7 +87,7 @@ void Painter::renderSDF(SymbolBucket &bucket, sdfShader.u_buffer = (haloOffset - styleProperties.halo_width / fontScale) / sdfPx; - depthRange(strata, 1.0f); + config.depthRange = { strata, 1.0f }; (bucket.*drawSDF)(sdfShader); } @@ -108,7 +108,7 @@ void Painter::renderSDF(SymbolBucket &bucket, sdfShader.u_buffer = (256.0f - 64.0f) / 256.0f; - depthRange(strata + strata_epsilon, 1.0f); + config.depthRange = { strata + strata_epsilon, 1.0f }; (bucket.*drawSDF)(sdfShader); } } @@ -122,8 +122,9 @@ void Painter::renderSymbol(SymbolBucket &bucket, const StyleLayer &layer_desc, c const auto &properties = layer_desc.getProperties(); const auto &layout = bucket.layout; - MBGL_CHECK_ERROR(glDisable(GL_STENCIL_TEST)); - depthMask(false); + config.stencilTest = false; + config.depthTest = true; + config.depthMask = GL_FALSE; if (bucket.hasIconData()) { bool sdf = bucket.sdfIcons; @@ -185,7 +186,7 @@ void Painter::renderSymbol(SymbolBucket &bucket, const StyleLayer &layer_desc, c iconShader->u_fadezoom = state.getNormalizedZoom() * 10; iconShader->u_opacity = properties.icon.opacity; - depthRange(strata, 1.0f); + config.depthRange = { strata, 1.0f }; bucket.drawIcons(*iconShader); } } @@ -203,6 +204,4 @@ void Painter::renderSymbol(SymbolBucket &bucket, const StyleLayer &layer_desc, c *sdfGlyphShader, &SymbolBucket::drawGlyphs); } - - MBGL_CHECK_ERROR(glEnable(GL_STENCIL_TEST)); } From 78073d6fdddf9b3675b28c2afb56a7a99bdd6dcf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Tue, 28 Apr 2015 18:10:29 +0200 Subject: [PATCH 11/14] don't reallocate the Glyph atlas too often - previously, we reallocated the glyph atlas on every upload. Instead, we're now using glTexSubImage2D to reuse the existing buffer - we're no longer forcing a texture upload when we remove glyphs; they won't be rendered anyway - we're now only doing a texture upload once per frame; previously, worker threads that added glyphs mid-render could trigger a texture upload while rendering is in progress --- src/mbgl/geometry/glyph_atlas.cpp | 47 +++++++++++++++++++++++-------- 1 file changed, 35 insertions(+), 12 deletions(-) diff --git a/src/mbgl/geometry/glyph_atlas.cpp b/src/mbgl/geometry/glyph_atlas.cpp index 378664f30..f2978de98 100644 --- a/src/mbgl/geometry/glyph_atlas.cpp +++ b/src/mbgl/geometry/glyph_atlas.cpp @@ -124,8 +124,6 @@ void GlyphAtlas::removeGlyphs(uintptr_t tileUID) { } } - dirty = true; - bin.release(rect); // Make sure to post-increment the iterator: This will return the @@ -142,7 +140,42 @@ void GlyphAtlas::removeGlyphs(uintptr_t tileUID) { void GlyphAtlas::upload() { if (dirty) { + const bool first = !texture; bind(); + + std::lock_guard lock(mtx); + + if (first) { + MBGL_CHECK_ERROR(glTexImage2D( + GL_TEXTURE_2D, // GLenum target + 0, // GLint level + GL_ALPHA, // GLint internalformat + width, // GLsizei width + height, // GLsizei height + 0, // GLint border + GL_ALPHA, // GLenum format + GL_UNSIGNED_BYTE, // GLenum type + data.get() // const GLvoid* data + )); + } else { + MBGL_CHECK_ERROR(glTexSubImage2D( + GL_TEXTURE_2D, // GLenum target + 0, // GLint level + 0, // GLint xoffset + 0, // GLint yoffset + width, // GLsizei width + height, // GLsizei height + GL_ALPHA, // GLenum format + GL_UNSIGNED_BYTE, // GLenum type + data.get() // const GLvoid* data + )); + } + + dirty = false; + +#if defined(DEBUG) + // platform::showDebugImage("Glyph Atlas", data.get(), width, height); +#endif } } @@ -160,14 +193,4 @@ void GlyphAtlas::bind() { } else { MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, texture)); } - - if (dirty) { - std::lock_guard lock(mtx); - MBGL_CHECK_ERROR(glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, data.get())); - dirty = false; - -#if defined(DEBUG) - // platform::showDebugImage("Glyph Atlas", data, width, height); -#endif - } }; From 99ad8a4036baf9adcc9e083e31fa6fea2516bd06 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Tue, 28 Apr 2015 18:12:27 +0200 Subject: [PATCH 12/14] fix needsUpload() --- src/mbgl/renderer/bucket.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp index 36210f9cb..711fc4238 100644 --- a/src/mbgl/renderer/bucket.hpp +++ b/src/mbgl/renderer/bucket.hpp @@ -24,7 +24,7 @@ public: virtual ~Bucket() {} inline bool needsUpload() const { - return uploaded; + return !uploaded; } protected: From 7390062c4589877dfc51e0b6f84e2fd5446b7a96 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Tue, 28 Apr 2015 18:12:52 +0200 Subject: [PATCH 13/14] check for errors --- src/mbgl/geometry/line_atlas.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/mbgl/geometry/line_atlas.cpp b/src/mbgl/geometry/line_atlas.cpp index 0dcaab2c4..42d238077 100644 --- a/src/mbgl/geometry/line_atlas.cpp +++ b/src/mbgl/geometry/line_atlas.cpp @@ -153,7 +153,7 @@ void LineAtlas::bind() { if (dirty) { if (first) { - glTexImage2D( + MBGL_CHECK_ERROR(glTexImage2D( GL_TEXTURE_2D, // GLenum target 0, // GLint level GL_ALPHA, // GLint internalformat @@ -163,9 +163,9 @@ void LineAtlas::bind() { GL_ALPHA, // GLenum format GL_UNSIGNED_BYTE, // GLenum type data // const GLvoid * data - ); + )); } else { - glTexSubImage2D( + MBGL_CHECK_ERROR(glTexSubImage2D( GL_TEXTURE_2D, // GLenum target 0, // GLint level 0, // GLint xoffset @@ -175,7 +175,7 @@ void LineAtlas::bind() { GL_ALPHA, // GLenum format GL_UNSIGNED_BYTE, // GLenum type data // const GLvoid *pixels - ); + )); } From 27d8e82e1ce7c6210a33f100cfb4f157ea9583d2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Tue, 28 Apr 2015 18:23:32 +0200 Subject: [PATCH 14/14] lower thread priority of worker threads --- gyp/platform-android.gypi | 1 + gyp/platform-ios.gypi | 1 + gyp/platform-linux.gypi | 1 + gyp/platform-osx.gypi | 1 + include/mbgl/platform/platform.hpp | 3 +++ platform/darwin/nsthread.mm | 13 +++++++++++++ platform/default/sqlite_cache.cpp | 2 +- platform/default/thread.cpp | 11 +++++++++++ src/mbgl/map/map.cpp | 2 +- src/mbgl/storage/default_file_source.cpp | 2 +- src/mbgl/util/thread.hpp | 14 ++++++++++++-- src/mbgl/util/worker.cpp | 3 ++- 12 files changed, 48 insertions(+), 6 deletions(-) create mode 100644 platform/darwin/nsthread.mm create mode 100644 platform/default/thread.cpp diff --git a/gyp/platform-android.gypi b/gyp/platform-android.gypi index bfaac7d4f..7701393bb 100644 --- a/gyp/platform-android.gypi +++ b/gyp/platform-android.gypi @@ -12,6 +12,7 @@ 'sources': [ '../platform/android/log_android.cpp', '../platform/android/asset_root.cpp', + '../platform/default/thread.cpp', '../platform/default/string_stdlib.cpp', '../platform/default/image.cpp', '../platform/default/image_reader.cpp', diff --git a/gyp/platform-ios.gypi b/gyp/platform-ios.gypi index f1f95d908..d23192c8c 100644 --- a/gyp/platform-ios.gypi +++ b/gyp/platform-ios.gypi @@ -15,6 +15,7 @@ '../platform/darwin/application_root.mm', '../platform/darwin/asset_root.mm', '../platform/darwin/image.mm', + '../platform/darwin/nsthread.mm', '../platform/darwin/reachability.m', '../include/mbgl/ios/MapboxGL.h', '../include/mbgl/ios/MGLMapboxEvents.h', diff --git a/gyp/platform-linux.gypi b/gyp/platform-linux.gypi index 30715f828..394433870 100644 --- a/gyp/platform-linux.gypi +++ b/gyp/platform-linux.gypi @@ -14,6 +14,7 @@ '../platform/default/string_stdlib.cpp', '../platform/default/application_root.cpp', '../platform/default/asset_root.cpp', + '../platform/default/thread.cpp', '../platform/default/image.cpp', '../platform/default/image_reader.cpp', '../platform/default/png_reader.cpp', diff --git a/gyp/platform-osx.gypi b/gyp/platform-osx.gypi index 6d6c35b29..ae5194761 100644 --- a/gyp/platform-osx.gypi +++ b/gyp/platform-osx.gypi @@ -15,6 +15,7 @@ '../platform/darwin/application_root.mm', '../platform/darwin/asset_root.mm', '../platform/darwin/image.mm', + '../platform/darwin/nsthread.mm', ], 'variables': { diff --git a/include/mbgl/platform/platform.hpp b/include/mbgl/platform/platform.hpp index cd87e2256..f828af37f 100644 --- a/include/mbgl/platform/platform.hpp +++ b/include/mbgl/platform/platform.hpp @@ -21,6 +21,9 @@ const std::string &applicationRoot(); // Returns the path to the asset location. const std::string &assetRoot(); +// Makes the current thread low priority. +void makeThreadLowPriority(); + // Shows an alpha image with the specified dimensions in a named window. void showDebugImage(std::string name, const char *data, size_t width, size_t height); diff --git a/platform/darwin/nsthread.mm b/platform/darwin/nsthread.mm new file mode 100644 index 000000000..9ac1d2caa --- /dev/null +++ b/platform/darwin/nsthread.mm @@ -0,0 +1,13 @@ +#import + +#include + +namespace mbgl { +namespace platform { + +void makeThreadLowPriority() { + [[NSThread currentThread] setThreadPriority:0.0]; +} + +} +} diff --git a/platform/default/sqlite_cache.cpp b/platform/default/sqlite_cache.cpp index 83d42d5a5..fb4cdf74e 100644 --- a/platform/default/sqlite_cache.cpp +++ b/platform/default/sqlite_cache.cpp @@ -62,7 +62,7 @@ std::string unifyMapboxURLs(const std::string &url) { using namespace mapbox::sqlite; SQLiteCache::SQLiteCache(const std::string& path_) - : thread(util::make_unique>("SQLite Cache", path_)) { + : thread(util::make_unique>("SQLite Cache", util::ThreadPriority::Low, path_)) { } SQLiteCache::~SQLiteCache() = default; diff --git a/platform/default/thread.cpp b/platform/default/thread.cpp new file mode 100644 index 000000000..c0a1069b9 --- /dev/null +++ b/platform/default/thread.cpp @@ -0,0 +1,11 @@ +#include + +namespace mbgl { +namespace platform { + +void makeThreadLowPriority() { + // no-op +} + +} +} diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp index be2355206..0464ed3f1 100644 --- a/src/mbgl/map/map.cpp +++ b/src/mbgl/map/map.cpp @@ -11,7 +11,7 @@ namespace mbgl { Map::Map(View& view, FileSource& fileSource, MapMode mode, bool startPaused) : data(util::make_unique(view, mode)), - context(util::make_unique>("Map", view, fileSource, *data, startPaused)) + context(util::make_unique>("Map", util::ThreadPriority::Regular, view, fileSource, *data, startPaused)) { view.initialize(this); } diff --git a/src/mbgl/storage/default_file_source.cpp b/src/mbgl/storage/default_file_source.cpp index 1063b22ec..ddfcc8984 100644 --- a/src/mbgl/storage/default_file_source.cpp +++ b/src/mbgl/storage/default_file_source.cpp @@ -27,7 +27,7 @@ namespace algo = boost::algorithm; namespace mbgl { DefaultFileSource::DefaultFileSource(FileCache* cache, const std::string& root) - : thread(util::make_unique>("FileSource", cache, root)) { + : thread(util::make_unique>("FileSource", util::ThreadPriority::Low, cache, root)) { } DefaultFileSource::~DefaultFileSource() { diff --git a/src/mbgl/util/thread.hpp b/src/mbgl/util/thread.hpp index 55c3d4d28..e97872a50 100644 --- a/src/mbgl/util/thread.hpp +++ b/src/mbgl/util/thread.hpp @@ -7,6 +7,7 @@ #include #include +#include namespace { @@ -34,11 +35,16 @@ namespace util { // Thread<> constructor blocks until the thread and the Object are fully created, so after the // object creation, it's safe to obtain the Object stored in this thread. +enum class ThreadPriority : bool { + Regular, + Low, +}; + template class Thread { public: template - Thread(const std::string& name, Args&&... args); + Thread(const std::string& name, ThreadPriority priority, Args&&... args); ~Thread(); // Invoke object->fn(args...) in the runloop thread. @@ -97,7 +103,7 @@ private: template template -Thread::Thread(const std::string& name, Args&&... args) { +Thread::Thread(const std::string& name, ThreadPriority priority, Args&&... args) { // Note: We're using std::tuple<> to store the arguments because GCC 4.9 has a bug // when expanding parameters packs captured in lambdas. std::tuple params = std::forward_as_tuple(::std::forward(args)...); @@ -109,6 +115,10 @@ Thread::Thread(const std::string& name, Args&&... args) { (void(name)); #endif + if (priority == ThreadPriority::Low) { + platform::makeThreadLowPriority(); + } + constexpr auto seq = typename integer_sequence::type(); run(std::move(params), seq); }); diff --git a/src/mbgl/util/worker.cpp b/src/mbgl/util/worker.cpp index 1a6eaf4d9..9792f1a09 100644 --- a/src/mbgl/util/worker.cpp +++ b/src/mbgl/util/worker.cpp @@ -1,4 +1,5 @@ #include +#include #include @@ -15,7 +16,7 @@ public: Worker::Worker(std::size_t count) { for (std::size_t i = 0; i < count; i++) { - threads.emplace_back(util::make_unique>("Worker")); + threads.emplace_back(util::make_unique>("Worker", util::ThreadPriority::Low)); } }