diff options
Diffstat (limited to 'src/mbgl/renderer')
59 files changed, 549 insertions, 306 deletions
diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp index e345f0b5ec..a0d2895b70 100644 --- a/src/mbgl/renderer/bucket.hpp +++ b/src/mbgl/renderer/bucket.hpp @@ -9,7 +9,7 @@ namespace mbgl { namespace gfx { -class Context; +class UploadPass; } // namespace gfx class RenderLayer; @@ -33,7 +33,7 @@ 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 upload(gfx::Context&) = 0; + virtual void upload(gfx::UploadPass&) = 0; virtual bool hasData() const = 0; diff --git a/src/mbgl/renderer/buckets/circle_bucket.cpp b/src/mbgl/renderer/buckets/circle_bucket.cpp index 376f4e682f..d9ba5f31ca 100644 --- a/src/mbgl/renderer/buckets/circle_bucket.cpp +++ b/src/mbgl/renderer/buckets/circle_bucket.cpp @@ -24,12 +24,12 @@ CircleBucket::CircleBucket(const BucketParameters& parameters, const std::vector CircleBucket::~CircleBucket() = default; -void CircleBucket::upload(gfx::Context& context) { - vertexBuffer = context.createVertexBuffer(std::move(vertices)); - indexBuffer = context.createIndexBuffer(std::move(triangles)); +void CircleBucket::upload(gfx::UploadPass& uploadPass) { + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + indexBuffer = uploadPass.createIndexBuffer(std::move(triangles)); for (auto& pair : paintPropertyBinders) { - pair.second.upload(context); + pair.second.upload(uploadPass); } uploaded = true; diff --git a/src/mbgl/renderer/buckets/circle_bucket.hpp b/src/mbgl/renderer/buckets/circle_bucket.hpp index 58f76327ab..145748f313 100644 --- a/src/mbgl/renderer/buckets/circle_bucket.hpp +++ b/src/mbgl/renderer/buckets/circle_bucket.hpp @@ -25,7 +25,7 @@ public: bool hasData() const override; - void upload(gfx::Context&) override; + void upload(gfx::UploadPass&) override; float getQueryRadius(const RenderLayer&) const override; bool supportsLayer(const style::Layer::Impl&) const override; diff --git a/src/mbgl/renderer/buckets/debug_bucket.cpp b/src/mbgl/renderer/buckets/debug_bucket.cpp index dac7622996..13380c0905 100644 --- a/src/mbgl/renderer/buckets/debug_bucket.cpp +++ b/src/mbgl/renderer/buckets/debug_bucket.cpp @@ -1,5 +1,4 @@ #include <mbgl/renderer/buckets/debug_bucket.hpp> -#include <mbgl/programs/fill_program.hpp> #include <mbgl/geometry/debug_font_data.hpp> #include <mbgl/tile/tile_id.hpp> #include <mbgl/util/string.hpp> @@ -16,8 +15,7 @@ DebugBucket::DebugBucket(const OverscaledTileID& id, const bool complete_, optional<Timestamp> modified_, optional<Timestamp> expires_, - MapDebugOptions debugMode_, - gfx::Context& context) + MapDebugOptions debugMode_) : renderable(renderable_), complete(complete_), modified(std::move(modified_)), @@ -25,9 +23,6 @@ DebugBucket::DebugBucket(const OverscaledTileID& id, debugMode(debugMode_), drawScopeID("__debug/" + util::toHex(util::nextID())) { - gfx::VertexVector<FillLayoutVertex> vertices; - gfx::IndexVector<gfx::Lines> indices; - auto addText = [&] (const std::string& text, double left, double baseline, double scale) { for (uint8_t c : text) { if (c < 32 || c >= 127) @@ -77,10 +72,12 @@ DebugBucket::DebugBucket(const OverscaledTileID& id, } segments.emplace_back(0, 0, vertices.elements(), indices.elements()); +} +void DebugBucket::upload(gfx::UploadPass& uploadPass) { if (!vertices.empty()) { - vertexBuffer = context.createVertexBuffer(std::move(vertices)); - indexBuffer = context.createIndexBuffer(std::move(indices)); + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + indexBuffer = uploadPass.createIndexBuffer(std::move(indices)); } } diff --git a/src/mbgl/renderer/buckets/debug_bucket.hpp b/src/mbgl/renderer/buckets/debug_bucket.hpp index 30d5ff67c8..2b735b4987 100644 --- a/src/mbgl/renderer/buckets/debug_bucket.hpp +++ b/src/mbgl/renderer/buckets/debug_bucket.hpp @@ -8,13 +8,14 @@ #include <mbgl/gfx/vertex_buffer.hpp> #include <mbgl/gfx/index_buffer.hpp> #include <mbgl/programs/debug_program.hpp> +#include <mbgl/programs/fill_program.hpp> namespace mbgl { class OverscaledTileID; namespace gl { -class Context; +class UploadPass; } // namespace gl class DebugBucket : private util::noncopyable { @@ -24,8 +25,9 @@ public: bool complete, optional<Timestamp> modified, optional<Timestamp> expires, - MapDebugOptions, - gfx::Context&); + MapDebugOptions); + + void upload(gfx::UploadPass&); const bool renderable; const bool complete; @@ -33,6 +35,10 @@ public: const optional<Timestamp> expires; const MapDebugOptions debugMode; + + gfx::VertexVector<FillLayoutVertex> vertices; + gfx::IndexVector<gfx::Lines> indices; + SegmentVector<DebugAttributes> segments; optional<gfx::VertexBuffer<DebugLayoutVertex>> vertexBuffer; optional<gfx::IndexBuffer> indexBuffer; diff --git a/src/mbgl/renderer/buckets/fill_bucket.cpp b/src/mbgl/renderer/buckets/fill_bucket.cpp index c69b60327d..e4cfd339d4 100644 --- a/src/mbgl/renderer/buckets/fill_bucket.cpp +++ b/src/mbgl/renderer/buckets/fill_bucket.cpp @@ -121,13 +121,13 @@ void FillBucket::addFeature(const GeometryTileFeature& feature, } } -void FillBucket::upload(gfx::Context& context) { - vertexBuffer = context.createVertexBuffer(std::move(vertices)); - lineIndexBuffer = context.createIndexBuffer(std::move(lines)); - triangleIndexBuffer = context.createIndexBuffer(std::move(triangles)); +void FillBucket::upload(gfx::UploadPass& uploadPass) { + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + lineIndexBuffer = uploadPass.createIndexBuffer(std::move(lines)); + triangleIndexBuffer = uploadPass.createIndexBuffer(std::move(triangles)); for (auto& pair : paintPropertyBinders) { - pair.second.upload(context); + pair.second.upload(uploadPass); } uploaded = true; diff --git a/src/mbgl/renderer/buckets/fill_bucket.hpp b/src/mbgl/renderer/buckets/fill_bucket.hpp index 217524c945..1a0d77dff7 100644 --- a/src/mbgl/renderer/buckets/fill_bucket.hpp +++ b/src/mbgl/renderer/buckets/fill_bucket.hpp @@ -33,7 +33,7 @@ public: bool hasData() const override; - void upload(gfx::Context&) override; + void upload(gfx::UploadPass&) override; float getQueryRadius(const RenderLayer&) const override; bool supportsLayer(const style::Layer::Impl&) const override; diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp index 7fa7293f33..51202b3ee4 100644 --- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp +++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp @@ -165,12 +165,12 @@ void FillExtrusionBucket::addFeature(const GeometryTileFeature& feature, } } -void FillExtrusionBucket::upload(gfx::Context& context) { - vertexBuffer = context.createVertexBuffer(std::move(vertices)); - indexBuffer = context.createIndexBuffer(std::move(triangles)); +void FillExtrusionBucket::upload(gfx::UploadPass& uploadPass) { + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + indexBuffer = uploadPass.createIndexBuffer(std::move(triangles)); for (auto& pair : paintPropertyBinders) { - pair.second.upload(context); + pair.second.upload(uploadPass); } uploaded = true; diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp index 85867031a7..8fa2f4f8e8 100644 --- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp +++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp @@ -33,7 +33,7 @@ public: bool supportsLayer(const style::Layer::Impl&) const override; - void upload(gfx::Context&) override; + void upload(gfx::UploadPass&) override; float getQueryRadius(const RenderLayer&) const override; diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.cpp b/src/mbgl/renderer/buckets/heatmap_bucket.cpp index 111911a88c..287c9ed26a 100644 --- a/src/mbgl/renderer/buckets/heatmap_bucket.cpp +++ b/src/mbgl/renderer/buckets/heatmap_bucket.cpp @@ -24,12 +24,12 @@ HeatmapBucket::HeatmapBucket(const BucketParameters& parameters, const std::vect HeatmapBucket::~HeatmapBucket() = default; -void HeatmapBucket::upload(gfx::Context& context) { - vertexBuffer = context.createVertexBuffer(std::move(vertices)); - indexBuffer = context.createIndexBuffer(std::move(triangles)); +void HeatmapBucket::upload(gfx::UploadPass& uploadPass) { + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + indexBuffer = uploadPass.createIndexBuffer(std::move(triangles)); for (auto& pair : paintPropertyBinders) { - pair.second.upload(context); + pair.second.upload(uploadPass); } uploaded = true; diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.hpp b/src/mbgl/renderer/buckets/heatmap_bucket.hpp index b11c1626cd..e3d0b7c769 100644 --- a/src/mbgl/renderer/buckets/heatmap_bucket.hpp +++ b/src/mbgl/renderer/buckets/heatmap_bucket.hpp @@ -24,7 +24,7 @@ public: const PatternLayerMap&) override; bool hasData() const override; - void upload(gfx::Context&) override; + void upload(gfx::UploadPass&) override; float getQueryRadius(const RenderLayer&) const override; bool supportsLayer(const style::Layer::Impl&) const override; diff --git a/src/mbgl/renderer/buckets/hillshade_bucket.cpp b/src/mbgl/renderer/buckets/hillshade_bucket.cpp index 3c14845dd8..08f941f990 100644 --- a/src/mbgl/renderer/buckets/hillshade_bucket.cpp +++ b/src/mbgl/renderer/buckets/hillshade_bucket.cpp @@ -26,18 +26,18 @@ DEMData& HillshadeBucket::getDEMData() { return demdata; } -void HillshadeBucket::upload(gfx::Context& context) { +void HillshadeBucket::upload(gfx::UploadPass& uploadPass) { if (!hasData()) { return; } const PremultipliedImage* image = demdata.getImage(); - dem = context.createTexture(*image); + dem = uploadPass.createTexture(*image); if (!segments.empty()) { - vertexBuffer = context.createVertexBuffer(std::move(vertices)); - indexBuffer = context.createIndexBuffer(std::move(indices)); + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + indexBuffer = uploadPass.createIndexBuffer(std::move(indices)); } uploaded = true; } diff --git a/src/mbgl/renderer/buckets/hillshade_bucket.hpp b/src/mbgl/renderer/buckets/hillshade_bucket.hpp index f3e89642cc..08acdff0c3 100644 --- a/src/mbgl/renderer/buckets/hillshade_bucket.hpp +++ b/src/mbgl/renderer/buckets/hillshade_bucket.hpp @@ -22,7 +22,7 @@ public: HillshadeBucket(DEMData&&); ~HillshadeBucket() override; - void upload(gfx::Context&) override; + void upload(gfx::UploadPass&) override; bool hasData() const override; bool supportsLayer(const style::Layer::Impl&) const override; diff --git a/src/mbgl/renderer/buckets/line_bucket.cpp b/src/mbgl/renderer/buckets/line_bucket.cpp index c2cce632b3..0536992707 100644 --- a/src/mbgl/renderer/buckets/line_bucket.cpp +++ b/src/mbgl/renderer/buckets/line_bucket.cpp @@ -508,12 +508,12 @@ void LineBucket::addPieSliceVertex(const GeometryCoordinate& currentVertex, } } -void LineBucket::upload(gfx::Context& context) { - vertexBuffer = context.createVertexBuffer(std::move(vertices)); - indexBuffer = context.createIndexBuffer(std::move(triangles)); +void LineBucket::upload(gfx::UploadPass& uploadPass) { + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + indexBuffer = uploadPass.createIndexBuffer(std::move(triangles)); for (auto& pair : paintPropertyBinders) { - pair.second.upload(context); + pair.second.upload(uploadPass); } uploaded = true; diff --git a/src/mbgl/renderer/buckets/line_bucket.hpp b/src/mbgl/renderer/buckets/line_bucket.hpp index 9afe7fecee..342f5cd88c 100644 --- a/src/mbgl/renderer/buckets/line_bucket.hpp +++ b/src/mbgl/renderer/buckets/line_bucket.hpp @@ -33,7 +33,7 @@ public: bool hasData() const override; - void upload(gfx::Context&) override; + void upload(gfx::UploadPass&) override; float getQueryRadius(const RenderLayer&) const override; bool supportsLayer(const style::Layer::Impl&) const override; diff --git a/src/mbgl/renderer/buckets/raster_bucket.cpp b/src/mbgl/renderer/buckets/raster_bucket.cpp index 7afb6172f5..57d3ba1896 100644 --- a/src/mbgl/renderer/buckets/raster_bucket.cpp +++ b/src/mbgl/renderer/buckets/raster_bucket.cpp @@ -1,7 +1,7 @@ #include <mbgl/renderer/buckets/raster_bucket.hpp> #include <mbgl/renderer/layers/render_raster_layer.hpp> #include <mbgl/programs/raster_program.hpp> -#include <mbgl/gfx/context.hpp> +#include <mbgl/gfx/upload_pass.hpp> #include <mbgl/util/id.hpp> namespace mbgl { @@ -20,16 +20,16 @@ RasterBucket::RasterBucket(std::shared_ptr<PremultipliedImage> image_) RasterBucket::~RasterBucket() = default; -void RasterBucket::upload(gfx::Context& context) { +void RasterBucket::upload(gfx::UploadPass& uploadPass) { if (!hasData()) { return; } if (!texture) { - texture = context.createTexture(*image); + texture = uploadPass.createTexture(*image); } if (!segments.empty()) { - vertexBuffer = context.createVertexBuffer(std::move(vertices)); - indexBuffer = context.createIndexBuffer(std::move(indices)); + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices)); + indexBuffer = uploadPass.createIndexBuffer(std::move(indices)); } uploaded = true; } diff --git a/src/mbgl/renderer/buckets/raster_bucket.hpp b/src/mbgl/renderer/buckets/raster_bucket.hpp index db1de4d0d1..b6182f7b2c 100644 --- a/src/mbgl/renderer/buckets/raster_bucket.hpp +++ b/src/mbgl/renderer/buckets/raster_bucket.hpp @@ -18,7 +18,7 @@ public: RasterBucket(std::shared_ptr<PremultipliedImage>); ~RasterBucket() override; - void upload(gfx::Context&) override; + void upload(gfx::UploadPass&) override; bool hasData() const override; bool supportsLayer(const style::Layer::Impl&) const override; diff --git a/src/mbgl/renderer/buckets/symbol_bucket.cpp b/src/mbgl/renderer/buckets/symbol_bucket.cpp index fb5a38f913..f290288114 100644 --- a/src/mbgl/renderer/buckets/symbol_bucket.cpp +++ b/src/mbgl/renderer/buckets/symbol_bucket.cpp @@ -43,76 +43,76 @@ SymbolBucket::SymbolBucket(style::SymbolLayoutProperties::PossiblyEvaluated layo SymbolBucket::~SymbolBucket() = default; -void SymbolBucket::upload(gfx::Context& context) { +void SymbolBucket::upload(gfx::UploadPass& uploadPass) { if (hasTextData()) { if (!staticUploaded) { - text.indexBuffer = context.createIndexBuffer(std::move(text.triangles), sortFeaturesByY ? gfx::BufferUsageType::StreamDraw : gfx::BufferUsageType::StaticDraw); - text.vertexBuffer = context.createVertexBuffer(std::move(text.vertices)); + text.indexBuffer = uploadPass.createIndexBuffer(std::move(text.triangles), sortFeaturesByY ? gfx::BufferUsageType::StreamDraw : gfx::BufferUsageType::StaticDraw); + text.vertexBuffer = uploadPass.createVertexBuffer(std::move(text.vertices)); for (auto& pair : paintProperties) { - pair.second.textBinders.upload(context); + pair.second.textBinders.upload(uploadPass); } } else if (!sortUploaded) { - context.updateIndexBuffer(*text.indexBuffer, std::move(text.triangles)); + uploadPass.updateIndexBuffer(*text.indexBuffer, std::move(text.triangles)); } if (!dynamicUploaded) { - text.dynamicVertexBuffer = context.createVertexBuffer(std::move(text.dynamicVertices), gfx::BufferUsageType::StreamDraw); + text.dynamicVertexBuffer = uploadPass.createVertexBuffer(std::move(text.dynamicVertices), gfx::BufferUsageType::StreamDraw); } if (!placementChangesUploaded) { if (!text.opacityVertexBuffer) { - text.opacityVertexBuffer = context.createVertexBuffer(std::move(text.opacityVertices), gfx::BufferUsageType::StreamDraw); + text.opacityVertexBuffer = uploadPass.createVertexBuffer(std::move(text.opacityVertices), gfx::BufferUsageType::StreamDraw); } else { - context.updateVertexBuffer(*text.opacityVertexBuffer, std::move(text.opacityVertices)); + uploadPass.updateVertexBuffer(*text.opacityVertexBuffer, std::move(text.opacityVertices)); } } } if (hasIconData()) { if (!staticUploaded) { - icon.indexBuffer = context.createIndexBuffer(std::move(icon.triangles), sortFeaturesByY ? gfx::BufferUsageType::StreamDraw : gfx::BufferUsageType::StaticDraw); - icon.vertexBuffer = context.createVertexBuffer(std::move(icon.vertices)); + icon.indexBuffer = uploadPass.createIndexBuffer(std::move(icon.triangles), sortFeaturesByY ? gfx::BufferUsageType::StreamDraw : gfx::BufferUsageType::StaticDraw); + icon.vertexBuffer = uploadPass.createVertexBuffer(std::move(icon.vertices)); for (auto& pair : paintProperties) { - pair.second.iconBinders.upload(context); + pair.second.iconBinders.upload(uploadPass); } } else if (!sortUploaded) { - context.updateIndexBuffer(*icon.indexBuffer, std::move(icon.triangles)); + uploadPass.updateIndexBuffer(*icon.indexBuffer, std::move(icon.triangles)); } if (!dynamicUploaded) { - icon.dynamicVertexBuffer = context.createVertexBuffer(std::move(icon.dynamicVertices), gfx::BufferUsageType::StreamDraw); + icon.dynamicVertexBuffer = uploadPass.createVertexBuffer(std::move(icon.dynamicVertices), gfx::BufferUsageType::StreamDraw); } if (!placementChangesUploaded) { if (!icon.opacityVertexBuffer) { - icon.opacityVertexBuffer = context.createVertexBuffer(std::move(icon.opacityVertices), gfx::BufferUsageType::StreamDraw); + icon.opacityVertexBuffer = uploadPass.createVertexBuffer(std::move(icon.opacityVertices), gfx::BufferUsageType::StreamDraw); } else { - context.updateVertexBuffer(*icon.opacityVertexBuffer, std::move(icon.opacityVertices)); + uploadPass.updateVertexBuffer(*icon.opacityVertexBuffer, std::move(icon.opacityVertices)); } } } if (hasCollisionBoxData()) { if (!staticUploaded) { - collisionBox.indexBuffer = context.createIndexBuffer(std::move(collisionBox.lines)); - collisionBox.vertexBuffer = context.createVertexBuffer(std::move(collisionBox.vertices)); + collisionBox.indexBuffer = uploadPass.createIndexBuffer(std::move(collisionBox.lines)); + collisionBox.vertexBuffer = uploadPass.createVertexBuffer(std::move(collisionBox.vertices)); } if (!placementChangesUploaded) { if (!collisionBox.dynamicVertexBuffer) { - collisionBox.dynamicVertexBuffer = context.createVertexBuffer(std::move(collisionBox.dynamicVertices), gfx::BufferUsageType::StreamDraw); + collisionBox.dynamicVertexBuffer = uploadPass.createVertexBuffer(std::move(collisionBox.dynamicVertices), gfx::BufferUsageType::StreamDraw); } else { - context.updateVertexBuffer(*collisionBox.dynamicVertexBuffer, std::move(collisionBox.dynamicVertices)); + uploadPass.updateVertexBuffer(*collisionBox.dynamicVertexBuffer, std::move(collisionBox.dynamicVertices)); } } } if (hasCollisionCircleData()) { if (!staticUploaded) { - collisionCircle.indexBuffer = context.createIndexBuffer(std::move(collisionCircle.triangles)); - collisionCircle.vertexBuffer = context.createVertexBuffer(std::move(collisionCircle.vertices)); + collisionCircle.indexBuffer = uploadPass.createIndexBuffer(std::move(collisionCircle.triangles)); + collisionCircle.vertexBuffer = uploadPass.createVertexBuffer(std::move(collisionCircle.vertices)); } if (!placementChangesUploaded) { if (!collisionCircle.dynamicVertexBuffer) { - collisionCircle.dynamicVertexBuffer = context.createVertexBuffer(std::move(collisionCircle.dynamicVertices), gfx::BufferUsageType::StreamDraw); + collisionCircle.dynamicVertexBuffer = uploadPass.createVertexBuffer(std::move(collisionCircle.dynamicVertices), gfx::BufferUsageType::StreamDraw); } else { - context.updateVertexBuffer(*collisionCircle.dynamicVertexBuffer, std::move(collisionCircle.dynamicVertices)); + uploadPass.updateVertexBuffer(*collisionCircle.dynamicVertexBuffer, std::move(collisionCircle.dynamicVertices)); } } } diff --git a/src/mbgl/renderer/buckets/symbol_bucket.hpp b/src/mbgl/renderer/buckets/symbol_bucket.hpp index 7db17f0062..0b9c5e583f 100644 --- a/src/mbgl/renderer/buckets/symbol_bucket.hpp +++ b/src/mbgl/renderer/buckets/symbol_bucket.hpp @@ -54,7 +54,7 @@ public: const float tilePixelRatio); ~SymbolBucket() override; - void upload(gfx::Context&) override; + void upload(gfx::UploadPass&) override; bool hasData() const override; bool supportsLayer(const style::Layer::Impl&) const override; bool hasTextData() const; diff --git a/src/mbgl/renderer/image_atlas.cpp b/src/mbgl/renderer/image_atlas.cpp index 282f135ac9..da7f5a30be 100644 --- a/src/mbgl/renderer/image_atlas.cpp +++ b/src/mbgl/renderer/image_atlas.cpp @@ -1,4 +1,5 @@ #include <mbgl/renderer/image_atlas.hpp> +#include <mbgl/gfx/upload_pass.hpp> #include <mbgl/gfx/context.hpp> #include <mbgl/renderer/image_manager.hpp> @@ -52,26 +53,26 @@ const mapbox::Bin& _packImage(mapbox::ShelfPack& pack, const style::Image::Impl& return bin; } -void ImageAtlas::patchUpdatedImages(gfx::Context& context, gfx::Texture& atlasTexture, const ImageManager& imageManager) { +void ImageAtlas::patchUpdatedImages(gfx::UploadPass& uploadPass, gfx::Texture& atlasTexture, const ImageManager& imageManager) { for (auto& updatedImageVersion : imageManager.updatedImageVersions) { auto iconPosition = iconPositions.find(updatedImageVersion.first); if (iconPosition != iconPositions.end()) { - patchUpdatedImage(context, atlasTexture, iconPosition->second, imageManager, updatedImageVersion.first, updatedImageVersion.second); + patchUpdatedImage(uploadPass, atlasTexture, iconPosition->second, imageManager, updatedImageVersion.first, updatedImageVersion.second); } auto patternPosition = patternPositions.find(updatedImageVersion.first); if (patternPosition != patternPositions.end()) { - patchUpdatedImage(context, atlasTexture, patternPosition->second, imageManager, updatedImageVersion.first, updatedImageVersion.second); + patchUpdatedImage(uploadPass, atlasTexture, patternPosition->second, imageManager, updatedImageVersion.first, updatedImageVersion.second); } } } -void ImageAtlas::patchUpdatedImage(gfx::Context& context, gfx::Texture& atlasTexture, ImagePosition& position, const ImageManager& imageManager, const std::string& name, uint16_t version) { +void ImageAtlas::patchUpdatedImage(gfx::UploadPass& uploadPass, gfx::Texture& atlasTexture, ImagePosition& position, const ImageManager& imageManager, const std::string& name, uint16_t version) { if (position.version == version) return; auto updatedImage = imageManager.getImage(name); if (updatedImage == nullptr) return; - context.updateTextureSub(atlasTexture, updatedImage->image, position.textureRect.x, position.textureRect.y); + uploadPass.updateTextureSub(atlasTexture, updatedImage->image, position.textureRect.x, position.textureRect.y); position.version = version; } diff --git a/src/mbgl/renderer/image_atlas.hpp b/src/mbgl/renderer/image_atlas.hpp index 080a490ab2..b59153c4a6 100644 --- a/src/mbgl/renderer/image_atlas.hpp +++ b/src/mbgl/renderer/image_atlas.hpp @@ -10,8 +10,8 @@ namespace mbgl { namespace gfx { - class Texture; - class Context; +class UploadPass; +class Texture; } // namespace gfx class ImageManager; @@ -60,9 +60,9 @@ public: ImagePositions iconPositions; ImagePositions patternPositions; - void patchUpdatedImages(gfx::Context&, gfx::Texture&, const ImageManager&); + void patchUpdatedImages(gfx::UploadPass&, gfx::Texture&, const ImageManager&); private: - void patchUpdatedImage(gfx::Context&, gfx::Texture&, ImagePosition& position, const ImageManager& imageManager, const std::string& name, uint16_t version); + void patchUpdatedImage(gfx::UploadPass&, gfx::Texture&, ImagePosition& position, const ImageManager& imageManager, const std::string& name, uint16_t version); }; ImageAtlas makeImageAtlas(const ImageMap&, const ImageMap&, const std::unordered_map<std::string, uint32_t>& versionMap); diff --git a/src/mbgl/renderer/image_manager.cpp b/src/mbgl/renderer/image_manager.cpp index 936dac75c3..10375fe900 100644 --- a/src/mbgl/renderer/image_manager.cpp +++ b/src/mbgl/renderer/image_manager.cpp @@ -2,6 +2,7 @@ #include <mbgl/actor/actor.hpp> #include <mbgl/actor/scheduler.hpp> #include <mbgl/util/logging.hpp> +#include <mbgl/gfx/upload_pass.hpp> #include <mbgl/gfx/context.hpp> #include <mbgl/renderer/image_manager_observer.hpp> @@ -285,18 +286,19 @@ Size ImageManager::getPixelSize() const { }; } -void ImageManager::upload(gfx::Context& context) { +void ImageManager::upload(gfx::UploadPass& uploadPass) { if (!atlasTexture) { - atlasTexture = context.createTexture(atlasImage); + atlasTexture = uploadPass.createTexture(atlasImage); } else if (dirty) { - context.updateTexture(*atlasTexture, atlasImage); + uploadPass.updateTexture(*atlasTexture, atlasImage); } dirty = false; } -gfx::TextureBinding ImageManager::textureBinding(gfx::Context& context) { - upload(context); +gfx::TextureBinding ImageManager::textureBinding() { + assert(atlasTexture); + assert(!dirty); return { atlasTexture->getResource(), gfx::TextureFilterType::Linear }; } diff --git a/src/mbgl/renderer/image_manager.hpp b/src/mbgl/renderer/image_manager.hpp index c2d6466b3a..533259039f 100644 --- a/src/mbgl/renderer/image_manager.hpp +++ b/src/mbgl/renderer/image_manager.hpp @@ -19,7 +19,7 @@ template <class T> class Actor; namespace gfx { -class Context; +class UploadPass; } // namespace gfx class ImageRequestor; @@ -83,8 +83,8 @@ private: public: optional<ImagePosition> getPattern(const std::string& name); - gfx::TextureBinding textureBinding(gfx::Context&); - void upload(gfx::Context&); + gfx::TextureBinding textureBinding(); + void upload(gfx::UploadPass&); Size getPixelSize() const; diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp index 3eb9bc2a30..51c4f2ae4f 100644 --- a/src/mbgl/renderer/layers/render_background_layer.cpp +++ b/src/mbgl/renderer/layers/render_background_layer.cpp @@ -1,6 +1,7 @@ #include <mbgl/renderer/layers/render_background_layer.hpp> #include <mbgl/style/layers/background_layer_impl.hpp> #include <mbgl/renderer/bucket.hpp> +#include <mbgl/renderer/upload_parameters.hpp> #include <mbgl/renderer/paint_parameters.hpp> #include <mbgl/renderer/image_manager.hpp> #include <mbgl/renderer/render_static_data.hpp> @@ -37,6 +38,9 @@ void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters ¶met passes = properties->evaluated.get<style::BackgroundOpacity>() > 0 ? RenderPass::Translucent : RenderPass::None; + if (passes != RenderPass::None && !properties->evaluated.get<style::BackgroundPattern>().to.empty()) { + passes |= RenderPass::Upload; + } evaluatedProperties = std::move(properties); } @@ -48,6 +52,15 @@ bool RenderBackgroundLayer::hasCrossfade() const { return getCrossfade<BackgroundLayerProperties>(evaluatedProperties).t != 1; } +void RenderBackgroundLayer::upload(gfx::UploadPass&, UploadParameters& parameters) { + const auto& evaluated = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).evaluated; + if (!evaluated.get<BackgroundPattern>().to.empty()) { + // Ensures that the texture gets added and uploaded to the atlas. + parameters.imageManager.getPattern(evaluated.get<BackgroundPattern>().from); + parameters.imageManager.getPattern(evaluated.get<BackgroundPattern>().to); + } +} + void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) { // Note that for bottommost layers without a pattern, the background color is drawn with // glClear rather than this method. @@ -63,7 +76,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) { parameters.state.getZoom() ); const auto allAttributeBindings = program.computeAllAttributeBindings( - parameters.staticData.tileVertexBuffer, + *parameters.staticData.tileVertexBuffer, paintAttributeData, properties ); @@ -78,7 +91,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) { gfx::StencilMode::disabled(), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), - parameters.staticData.quadTriangleIndexBuffer, + *parameters.staticData.quadTriangleIndexBuffer, parameters.staticData.tileTriangleSegments, allUniformValues, allAttributeBindings, @@ -109,7 +122,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) { parameters.state ), BackgroundPatternProgram::TextureBindings{ - textures::image::Value{ parameters.imageManager.textureBinding(parameters.context) }, + textures::image::Value{ parameters.imageManager.textureBinding() }, } ); } diff --git a/src/mbgl/renderer/layers/render_background_layer.hpp b/src/mbgl/renderer/layers/render_background_layer.hpp index de553eef90..248a3e1457 100644 --- a/src/mbgl/renderer/layers/render_background_layer.hpp +++ b/src/mbgl/renderer/layers/render_background_layer.hpp @@ -17,6 +17,7 @@ private: bool hasTransition() const override; bool hasCrossfade() const override; optional<Color> getSolidBackground() const override; + void upload(gfx::UploadPass&, UploadParameters&) override; void render(PaintParameters&, RenderSource*) override; // Paint properties diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp index f1cce31ea4..053503bbaa 100644 --- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp +++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp @@ -41,7 +41,7 @@ void RenderHeatmapLayer::evaluate(const PropertyEvaluationParameters& parameters unevaluated.evaluate(parameters)); passes = (properties->evaluated.get<style::HeatmapOpacity>() > 0) - ? (RenderPass::Translucent | RenderPass::Pass3D) + ? (RenderPass::Translucent | RenderPass::Pass3D | RenderPass::Upload) : RenderPass::None; evaluatedProperties = std::move(properties); @@ -55,6 +55,13 @@ bool RenderHeatmapLayer::hasCrossfade() const { return false; } +void RenderHeatmapLayer::upload(gfx::UploadPass& uploadPass, UploadParameters&) { + if (!colorRampTexture) { + colorRampTexture = + uploadPass.createTexture(colorRamp, gfx::TextureChannelDataType::UnsignedByte); + } +} + void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) { if (parameters.pass == RenderPass::Opaque) { return; @@ -64,9 +71,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) { const auto& viewportSize = parameters.staticData.backendSize; const auto size = Size{viewportSize.width / 4, viewportSize.height / 4}; - if (!colorRampTexture) { - colorRampTexture = parameters.context.createTexture(colorRamp, gfx::TextureChannelDataType::UnsignedByte); - } + assert(colorRampTexture); if (!renderTexture || renderTexture->getSize() != size) { renderTexture.reset(); @@ -101,7 +106,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) { const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID()); auto& programInstance = parameters.programs.getHeatmapLayerPrograms().heatmap; - + const auto allUniformValues = programInstance.computeAllUniformValues( HeatmapProgram::LayoutUniformValues { uniforms::intensity::Value( evaluated.get<style::HeatmapIntensity>() ), @@ -159,7 +164,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) { parameters.state.getZoom() ); const auto allAttributeBindings = programInstance.computeAllAttributeBindings( - parameters.staticData.heatmapTextureVertexBuffer, + *parameters.staticData.heatmapTextureVertexBuffer, paintAttributeData, properties ); @@ -174,7 +179,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) { gfx::StencilMode::disabled(), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), - parameters.staticData.quadTriangleIndexBuffer, + *parameters.staticData.quadTriangleIndexBuffer, parameters.staticData.heatmapTextureSegments, allUniformValues, allAttributeBindings, diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.hpp b/src/mbgl/renderer/layers/render_heatmap_layer.hpp index 65dad9828b..f4c0299dd9 100644 --- a/src/mbgl/renderer/layers/render_heatmap_layer.hpp +++ b/src/mbgl/renderer/layers/render_heatmap_layer.hpp @@ -19,6 +19,7 @@ private: void evaluate(const PropertyEvaluationParameters&) override; bool hasTransition() const override; bool hasCrossfade() const override; + void upload(gfx::UploadPass&, UploadParameters&) override; void render(PaintParameters&, RenderSource*) override; bool queryIntersectsFeature( diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp index 19af5b6202..a13de7c4cd 100644 --- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp +++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp @@ -162,7 +162,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src parameters.state.getZoom() ); const auto allAttributeBindings = programInstance.computeAllAttributeBindings( - parameters.staticData.rasterVertexBuffer, + *parameters.staticData.rasterVertexBuffer, paintAttributeData, properties ); @@ -177,7 +177,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src gfx::StencilMode::disabled(), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), - parameters.staticData.quadTriangleIndexBuffer, + *parameters.staticData.quadTriangleIndexBuffer, parameters.staticData.rasterSegments, allUniformValues, allAttributeBindings, @@ -204,8 +204,8 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src } else { // Draw the full tile. draw(parameters.matrixForTile(tile.id, true), - parameters.staticData.rasterVertexBuffer, - parameters.staticData.quadTriangleIndexBuffer, + *parameters.staticData.rasterVertexBuffer, + *parameters.staticData.quadTriangleIndexBuffer, parameters.staticData.rasterSegments, tile.id, HillshadeProgram::TextureBindings{ diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp index a34c634f58..bfb6ac619e 100644 --- a/src/mbgl/renderer/layers/render_line_layer.cpp +++ b/src/mbgl/renderer/layers/render_line_layer.cpp @@ -2,6 +2,7 @@ #include <mbgl/renderer/buckets/line_bucket.hpp> #include <mbgl/renderer/render_tile.hpp> #include <mbgl/renderer/render_source.hpp> +#include <mbgl/renderer/upload_parameters.hpp> #include <mbgl/renderer/paint_parameters.hpp> #include <mbgl/renderer/image_manager.hpp> #include <mbgl/programs/programs.hpp> @@ -46,7 +47,7 @@ void RenderLineLayer::evaluate(const PropertyEvaluationParameters& parameters) { passes = (evaluated.get<style::LineOpacity>().constantOr(1.0) > 0 && evaluated.get<style::LineColor>().constantOr(Color::black()).a > 0 && evaluated.get<style::LineWidth>().constantOr(1.0) > 0) - ? RenderPass::Translucent : RenderPass::None; + ? RenderPass::Translucent | RenderPass::Upload : RenderPass::None; evaluatedProperties = std::move(properties); } @@ -58,6 +59,38 @@ bool RenderLineLayer::hasCrossfade() const { return getCrossfade<LineLayerProperties>(evaluatedProperties).t != 1; } +void RenderLineLayer::upload(gfx::UploadPass& uploadPass, UploadParameters& uploadParameters) { + for (const RenderTile& tile : renderTiles) { + const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl); + if (!renderData) { + continue; + } + auto& bucket = static_cast<LineBucket&>(*renderData->bucket); + const auto& evaluated = getEvaluated<LineLayerProperties>(renderData->layerProperties); + + if (!evaluated.get<LineDasharray>().from.empty()) { + const LinePatternCap cap = bucket.layout.get<LineCap>() == LineCapType::Round + ? LinePatternCap::Round : LinePatternCap::Square; + // Ensures that the dash data gets added and uploaded to the atlas. + uploadParameters.lineAtlas.getDashPosition(evaluated.get<LineDasharray>().from, cap); + uploadParameters.lineAtlas.getDashPosition(evaluated.get<LineDasharray>().to, cap); + + } else if (!unevaluated.get<LinePattern>().isUndefined()) { + const auto& linePatternValue = evaluated.get<LinePattern>().constantOr(Faded<std::basic_string<char>>{ "", ""}); + auto& geometryTile = static_cast<GeometryTile&>(tile.tile); + + // Ensures that the pattern gets added and uplodated to the atlas. + geometryTile.getPattern(linePatternValue.from); + geometryTile.getPattern(linePatternValue.to); + + } else if (!unevaluated.get<LineGradient>().getValue().isUndefined()) { + if (!colorRampTexture) { + colorRampTexture = uploadPass.createTexture(colorRamp); + } + } + } +} + void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) { if (parameters.pass == RenderPass::Opaque) { return; @@ -133,12 +166,12 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) { {}, {}, LineSDFProgram::TextureBindings{ - parameters.lineAtlas.textureBinding(parameters.context), + parameters.lineAtlas.textureBinding(), }); } else if (!unevaluated.get<LinePattern>().isUndefined()) { const auto& linePatternValue = evaluated.get<LinePattern>().constantOr(Faded<std::basic_string<char>>{ "", ""}); - auto& geometryTile = static_cast<GeometryTile&>(tile.tile); + auto& geometryTile = static_cast<GeometryTile&>(tile.tile); const Size texsize = geometryTile.iconAtlasTexture->size; optional<ImagePosition> posA = geometryTile.getPattern(linePatternValue.from); @@ -159,9 +192,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) { textures::image::Value{ geometryTile.iconAtlasTexture->getResource(), gfx::TextureFilterType::Linear }, }); } else if (!unevaluated.get<LineGradient>().getValue().isUndefined()) { - if (!colorRampTexture) { - colorRampTexture = parameters.context.createTexture(colorRamp); - } + assert(colorRampTexture); draw(parameters.programs.getLineLayerPrograms().lineGradient, LineGradientProgram::layoutUniformValues( diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp index 657f72e5f1..0e1e81e557 100644 --- a/src/mbgl/renderer/layers/render_line_layer.hpp +++ b/src/mbgl/renderer/layers/render_line_layer.hpp @@ -20,6 +20,7 @@ private: void evaluate(const PropertyEvaluationParameters&) override; bool hasTransition() const override; bool hasCrossfade() const override; + void upload(gfx::UploadPass&, UploadParameters&) override; void render(PaintParameters&, RenderSource*) override; bool queryIntersectsFeature( diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp index 8569303a06..ce4fb05929 100644 --- a/src/mbgl/renderer/layers/render_raster_layer.cpp +++ b/src/mbgl/renderer/layers/render_raster_layer.cpp @@ -175,8 +175,8 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source } else { // Draw the full tile. draw(parameters.matrixForTile(tile.id, true), - parameters.staticData.rasterVertexBuffer, - parameters.staticData.quadTriangleIndexBuffer, + *parameters.staticData.rasterVertexBuffer, + *parameters.staticData.quadTriangleIndexBuffer, parameters.staticData.rasterSegments, RasterProgram::TextureBindings{ textures::image0::Value{ bucket.texture->getResource(), filter }, diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp index 9429cff469..576bdd92d8 100644 --- a/src/mbgl/renderer/layers/render_symbol_layer.cpp +++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp @@ -3,6 +3,7 @@ #include <mbgl/renderer/bucket_parameters.hpp> #include <mbgl/renderer/property_evaluation_parameters.hpp> #include <mbgl/renderer/render_tile.hpp> +#include <mbgl/renderer/upload_parameters.hpp> #include <mbgl/renderer/paint_parameters.hpp> #include <mbgl/text/glyph_atlas.hpp> #include <mbgl/text/shaping.hpp> @@ -13,9 +14,11 @@ #include <mbgl/tile/geometry_tile.hpp> #include <mbgl/tile/geometry_tile_data.hpp> #include <mbgl/style/layers/symbol_layer_impl.hpp> +#include <mbgl/text/placement.hpp> #include <mbgl/gfx/cull_face_mode.hpp> #include <mbgl/layout/symbol_projection.hpp> #include <mbgl/layout/symbol_layout.hpp> +#include <mbgl/layout/symbol_layout.hpp> #include <mbgl/util/math.hpp> #include <cmath> @@ -112,6 +115,122 @@ struct RenderableSegment { } }; +void uploadIcon(gfx::UploadPass& uploadPass, + UploadParameters& uploadParameters, + const RenderTile& tile, + const LayerRenderData& renderData) { + assert(tile.tile.kind == Tile::Kind::Geometry); + auto& bucket = static_cast<SymbolBucket&>(*renderData.bucket); + const auto& layout = bucket.layout; + + const bool alongLine = layout.get<SymbolPlacement>() != SymbolPlacementType::Point && + layout.get<IconRotationAlignment>() == AlignmentType::Map; + + if (alongLine) { + const auto& evaluated = getEvaluated<SymbolLayerProperties>(renderData.layerProperties); + reprojectLineLabels(bucket.icon.dynamicVertices, bucket.icon.placedSymbols, tile.matrix, + iconPropertyValues(evaluated, layout), tile, *bucket.iconSizeBinder, + uploadParameters.state); + + uploadPass.updateVertexBuffer(*bucket.icon.dynamicVertexBuffer, + std::move(bucket.icon.dynamicVertices)); + } +} + +void uploadText(gfx::UploadPass& uploadPass, + UploadParameters& uploadParameters, + const RenderTile& tile, + const LayerRenderData& renderData, + bool& hasVariablePlacement) { + assert(tile.tile.kind == Tile::Kind::Geometry); + auto& bucket = static_cast<SymbolBucket&>(*renderData.bucket); + const auto& layout = bucket.layout; + + const bool alongLine = layout.get<SymbolPlacement>() != SymbolPlacementType::Point && + layout.get<TextRotationAlignment>() == AlignmentType::Map; + + if (alongLine) { + const auto& evaluated = getEvaluated<SymbolLayerProperties>(renderData.layerProperties); + reprojectLineLabels(bucket.text.dynamicVertices, + bucket.text.placedSymbols, + tile.matrix, + textPropertyValues(evaluated, layout), + tile, + *bucket.textSizeBinder, + uploadParameters.state); + + uploadPass.updateVertexBuffer(*bucket.text.dynamicVertexBuffer, std::move(bucket.text.dynamicVertices)); + } else if (!layout.get<TextVariableAnchor>().empty()) { + bucket.text.dynamicVertices.clear(); + + hasVariablePlacement = false; + + const auto partiallyEvaluatedSize = bucket.textSizeBinder->evaluateForZoom(uploadParameters.state.getZoom()); + const float tileScale = std::pow(2, uploadParameters.state.getZoom() - tile.tile.id.overscaledZ); + const bool rotateWithMap = layout.get<TextRotationAlignment>() == AlignmentType::Map; + const bool pitchWithMap = layout.get<TextPitchAlignment>() == AlignmentType::Map; + const float pixelsToTileUnits = tile.id.pixelsToTileUnits(1.0, uploadParameters.state.getZoom()); + const auto labelPlaneMatrix = getLabelPlaneMatrix(tile.matrix, pitchWithMap, rotateWithMap, uploadParameters.state, pixelsToTileUnits); + + for (const PlacedSymbol& symbol : bucket.text.placedSymbols) { + optional<VariableOffset> variableOffset; + if (!symbol.hidden && symbol.crossTileID != 0u) { + auto it = uploadParameters.variableOffsets.find(symbol.crossTileID); + if (it != uploadParameters.variableOffsets.end()) { + hasVariablePlacement |= true; + variableOffset = it->second; + } + } + + if (!variableOffset) { + // These symbols are from a justification that is not being used, or a label that wasn't placed + // so we don't need to do the extra math to figure out what incremental shift to apply. + hideGlyphs(symbol.glyphOffsets.size(), bucket.text.dynamicVertices); + } else { + const Point<float> tileAnchor = symbol.anchorPoint; + const auto projectedAnchor = project(tileAnchor, pitchWithMap ? tile.matrix : labelPlaneMatrix); + const float perspectiveRatio = 0.5f + 0.5f * (uploadParameters.state.getCameraToCenterDistance() / projectedAnchor.second); + float renderTextSize = evaluateSizeForFeature(partiallyEvaluatedSize, symbol) * perspectiveRatio / util::ONE_EM; + if (pitchWithMap) { + // Go from size in pixels to equivalent size in tile units + renderTextSize *= bucket.tilePixelRatio / tileScale; + } + + auto shift = calculateVariableRenderShift( + (*variableOffset).anchor, + (*variableOffset).width, + (*variableOffset).height, + (*variableOffset).radialOffset, + (*variableOffset).textBoxScale, + renderTextSize); + + // Usual case is that we take the projected anchor and add the pixel-based shift + // calculated above. In the (somewhat weird) case of pitch-aligned text, we add an equivalent + // tile-unit based shift to the anchor before projecting to the label plane. + Point<float> shiftedAnchor; + if (pitchWithMap) { + shiftedAnchor = project(Point<float>(tileAnchor.x + shift.x, tileAnchor.y + shift.y), + labelPlaneMatrix).first; + } else { + if (rotateWithMap) { + auto rotated = util::rotate(shift, -uploadParameters.state.getPitch()); + shiftedAnchor = Point<float>(projectedAnchor.first.x + rotated.x, + projectedAnchor.first.y + rotated.y); + } else { + shiftedAnchor = Point<float>(projectedAnchor.first.x + shift.x, + projectedAnchor.first.y + shift.y); + } + } + + for (std::size_t i = 0; i < symbol.glyphOffsets.size(); i++) { + addDynamicAttributes(shiftedAnchor, 0, bucket.text.dynamicVertices); + } + } + } + uploadPass.updateVertexBuffer(*bucket.text.dynamicVertexBuffer, std::move(bucket.text.dynamicVertices)); + } +} + template <typename DrawFn> void drawIcon(const DrawFn& draw, const RenderTile& tile, @@ -130,18 +249,6 @@ void drawIcon(const DrawFn& draw, const bool alongLine = layout.get<SymbolPlacement>() != SymbolPlacementType::Point && layout.get<IconRotationAlignment>() == AlignmentType::Map; - if (alongLine) { - reprojectLineLabels(bucket.icon.dynamicVertices, - bucket.icon.placedSymbols, - tile.matrix, - values, - tile, - *bucket.iconSizeBinder, - parameters.state); - - parameters.context.updateVertexBuffer(*bucket.icon.dynamicVertexBuffer, std::move(bucket.icon.dynamicVertices)); - } - const bool iconScaled = layout.get<IconSize>().constantOr(1.0) != 1.0 || bucket.iconsNeedLinear; const bool iconTransformed = values.rotationAlignment == AlignmentType::Map || parameters.state.getPitch() != 0; @@ -206,7 +313,8 @@ void drawText(const DrawFn& draw, const LayerRenderData& renderData, SegmentsWrapper textSegments, const SymbolBucket::PaintProperties& bucketPaintProperties, - const PaintParameters& parameters) { + const PaintParameters& parameters, + bool hasVariablePlacement) { assert(tile.tile.kind == Tile::Kind::Geometry); auto& geometryTile = static_cast<GeometryTile&>(tile.tile); auto& bucket = static_cast<SymbolBucket&>(*renderData.bucket); @@ -218,94 +326,15 @@ void drawText(const DrawFn& draw, auto values = textPropertyValues(evaluated, layout); const auto& paintPropertyValues = RenderSymbolLayer::textPaintProperties(evaluated); - bool hasVariablePacement = false; const bool alongLine = layout.get<SymbolPlacement>() != SymbolPlacementType::Point && layout.get<TextRotationAlignment>() == AlignmentType::Map; - if (alongLine) { - reprojectLineLabels(bucket.text.dynamicVertices, - bucket.text.placedSymbols, - tile.matrix, - values, - tile, - *bucket.textSizeBinder, - parameters.state); - - parameters.context.updateVertexBuffer(*bucket.text.dynamicVertexBuffer, std::move(bucket.text.dynamicVertices)); - } else if (!layout.get<TextVariableAnchor>().empty()) { - bucket.text.dynamicVertices.clear(); - - const auto partiallyEvaluatedSize = bucket.textSizeBinder->evaluateForZoom(parameters.state.getZoom()); - const float tileScale = std::pow(2, parameters.state.getZoom() - tile.tile.id.overscaledZ); - const bool rotateWithMap = layout.get<TextRotationAlignment>() == AlignmentType::Map; - const bool pitchWithMap = layout.get<TextPitchAlignment>() == AlignmentType::Map; - const float pixelsToTileUnits = tile.id.pixelsToTileUnits(1.0, parameters.state.getZoom()); - const auto labelPlaneMatrix = getLabelPlaneMatrix(tile.matrix, pitchWithMap, rotateWithMap, parameters.state, pixelsToTileUnits); - - for (const PlacedSymbol& symbol : bucket.text.placedSymbols) { - optional<VariableOffset> variableOffset; - if (!symbol.hidden && symbol.crossTileID != 0u) { - auto it = parameters.variableOffsets.get().find(symbol.crossTileID); - if (it != parameters.variableOffsets.get().end()) { - variableOffset = it->second; - hasVariablePacement |= true; - } - } - - if (!variableOffset) { - // These symbols are from a justification that is not being used, or a label that wasn't placed - // so we don't need to do the extra math to figure out what incremental shift to apply. - hideGlyphs(symbol.glyphOffsets.size(), bucket.text.dynamicVertices); - } else { - const Point<float> tileAnchor = symbol.anchorPoint; - const auto projectedAnchor = project(tileAnchor, pitchWithMap ? tile.matrix : labelPlaneMatrix); - const float perspectiveRatio = 0.5f + 0.5f * (parameters.state.getCameraToCenterDistance() / projectedAnchor.second); - float renderTextSize = evaluateSizeForFeature(partiallyEvaluatedSize, symbol) * perspectiveRatio / util::ONE_EM; - if (pitchWithMap) { - // Go from size in pixels to equivalent size in tile units - renderTextSize *= bucket.tilePixelRatio / tileScale; - } - - auto shift = calculateVariableRenderShift( - (*variableOffset).anchor, - (*variableOffset).width, - (*variableOffset).height, - (*variableOffset).radialOffset, - (*variableOffset).textBoxScale, - renderTextSize); - - // Usual case is that we take the projected anchor and add the pixel-based shift - // calculated above. In the (somewhat weird) case of pitch-aligned text, we add an equivalent - // tile-unit based shift to the anchor before projecting to the label plane. - Point<float> shiftedAnchor; - if (pitchWithMap) { - shiftedAnchor = project(Point<float>(tileAnchor.x + shift.x, tileAnchor.y + shift.y), - labelPlaneMatrix).first; - } else { - if (rotateWithMap) { - auto rotated = util::rotate(shift, -parameters.state.getPitch()); - shiftedAnchor = Point<float>(projectedAnchor.first.x + rotated.x, - projectedAnchor.first.y + rotated.y); - } else { - shiftedAnchor = Point<float>(projectedAnchor.first.x + shift.x, - projectedAnchor.first.y + shift.y); - } - } - - for (std::size_t i = 0; i < symbol.glyphOffsets.size(); i++) { - addDynamicAttributes(shiftedAnchor, 0, bucket.text.dynamicVertices); - } - } - } - parameters.context.updateVertexBuffer(*bucket.text.dynamicVertexBuffer, std::move(bucket.text.dynamicVertices)); - } - const Size texsize = geometryTile.glyphAtlasTexture->size; if (values.hasHalo) { draw(parameters.programs.getSymbolLayerPrograms().symbolGlyph, - SymbolSDFTextProgram::layoutUniformValues(true, hasVariablePacement, values, texsize, parameters.pixelsToGLUnits, parameters.pixelRatio, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo), + SymbolSDFTextProgram::layoutUniformValues(true, hasVariablePlacement, values, texsize, parameters.pixelsToGLUnits, parameters.pixelRatio, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo), bucket.text, textSegments, bucket.textSizeBinder, @@ -320,7 +349,7 @@ void drawText(const DrawFn& draw, if (values.hasFill) { draw(parameters.programs.getSymbolLayerPrograms().symbolGlyph, - SymbolSDFTextProgram::layoutUniformValues(true, hasVariablePacement, values, texsize, parameters.pixelsToGLUnits, parameters.pixelRatio, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill), + SymbolSDFTextProgram::layoutUniformValues(true, hasVariablePlacement, values, texsize, parameters.pixelsToGLUnits, parameters.pixelRatio, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill), bucket.text, textSegments, bucket.textSizeBinder, @@ -370,7 +399,8 @@ void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters) passes = ((evaluated.get<style::IconOpacity>().constantOr(1) > 0 && hasIconOpacity && iconSize > 0) || (evaluated.get<style::TextOpacity>().constantOr(1) > 0 && hasTextOpacity && textSize > 0)) - ? RenderPass::Translucent : RenderPass::None; + ? RenderPass::Translucent | RenderPass::Upload : RenderPass::None; + evaluatedProperties = std::move(properties); } @@ -398,6 +428,24 @@ SymbolBucket* RenderSymbolLayer::getSymbolBucket(const RenderTile& renderTile) c return renderTile.tile.getBucket<SymbolBucket>(*baseImpl); } +void RenderSymbolLayer::upload(gfx::UploadPass& uploadPass, UploadParameters& uploadParameters) { + for (const RenderTile& tile : renderTiles) { + const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl); + if (!renderData) { + continue; + } + + auto& bucket = static_cast<SymbolBucket&>(*renderData->bucket); + if (bucket.hasIconData()) { + uploadIcon(uploadPass, uploadParameters, tile, *renderData); + } + + if (bucket.hasTextData()) { + uploadText(uploadPass, uploadParameters, tile, *renderData, hasVariablePlacement); + } + } +} + void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) { if (parameters.pass == RenderPass::Opaque) { return; @@ -504,7 +552,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) { if (sortFeaturesByKey) { addRenderables(bucket.text.segments, true /*isText*/); } else { - drawText(draw, tile, *renderData, std::ref(bucket.text.segments), bucketPaintProperties, parameters); + drawText(draw, tile, *renderData, std::ref(bucket.text.segments), bucketPaintProperties, parameters, hasVariablePlacement); } } @@ -518,7 +566,6 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) { {{ parameters.pixelsToGLUnits[0] / (pixelRatio * scale), parameters.pixelsToGLUnits[1] / (pixelRatio * scale) - }}; parameters.programs.getSymbolLayerPrograms().collisionBox.draw( parameters.context, @@ -555,7 +602,6 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) { {{ parameters.pixelsToGLUnits[0] / (pixelRatio * scale), parameters.pixelsToGLUnits[1] / (pixelRatio * scale) - }}; parameters.programs.getSymbolLayerPrograms().collisionCircle.draw( @@ -588,7 +634,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) { if (sortFeaturesByKey) { for (auto& renderable : renderableSegments) { if (renderable.isText) { - drawText(draw, renderable.tile, renderable.renderData, renderable.segment, renderable.bucketPaintProperties, parameters); + drawText(draw, renderable.tile, renderable.renderData, renderable.segment, renderable.bucketPaintProperties, parameters, hasVariablePlacement); } else { drawIcon(draw, renderable.tile, renderable.renderData, renderable.segment, renderable.bucketPaintProperties, parameters); } diff --git a/src/mbgl/renderer/layers/render_symbol_layer.hpp b/src/mbgl/renderer/layers/render_symbol_layer.hpp index ad33a2ab0e..67b8a58314 100644 --- a/src/mbgl/renderer/layers/render_symbol_layer.hpp +++ b/src/mbgl/renderer/layers/render_symbol_layer.hpp @@ -66,6 +66,7 @@ private: void evaluate(const PropertyEvaluationParameters&) override; bool hasTransition() const override; bool hasCrossfade() const override; + void upload(gfx::UploadPass&, UploadParameters&) override; void render(PaintParameters&, RenderSource*) override; void setRenderTiles(RenderTiles, const TransformState&) override; @@ -82,6 +83,7 @@ private: float textSize = 16.0f; bool hasFormatSectionOverrides = false; + bool hasVariablePlacement = false; }; } // namespace mbgl diff --git a/src/mbgl/renderer/paint_parameters.cpp b/src/mbgl/renderer/paint_parameters.cpp index e31392902e..38cdb11f9f 100644 --- a/src/mbgl/renderer/paint_parameters.cpp +++ b/src/mbgl/renderer/paint_parameters.cpp @@ -17,8 +17,7 @@ PaintParameters::PaintParameters(gfx::Context& context_, const EvaluatedLight& evaluatedLight_, RenderStaticData& staticData_, ImageManager& imageManager_, - LineAtlas& lineAtlas_, - Placement::VariableOffsets variableOffsets_) + LineAtlas& lineAtlas_) : context(context_), backend(backend_), encoder(context.createCommandEncoder()), @@ -31,7 +30,6 @@ PaintParameters::PaintParameters(gfx::Context& context_, debugOptions(updateParameters.debugOptions), timePoint(updateParameters.timePoint), pixelRatio(pixelRatio_), - variableOffsets(variableOffsets_), #ifndef NDEBUG programs((debugOptions & MapDebugOptions::Overdraw) ? staticData_.overdrawPrograms : staticData_.programs) #else @@ -135,7 +133,7 @@ void PaintParameters::renderTileClippingMasks(const std::vector<std::reference_w }, gfx::ColorMode::disabled(), gfx::CullFaceMode::disabled(), - staticData.quadTriangleIndexBuffer, + *staticData.quadTriangleIndexBuffer, staticData.tileTriangleSegments, program.computeAllUniformValues( ClippingMaskProgram::LayoutUniformValues { @@ -146,7 +144,7 @@ void PaintParameters::renderTileClippingMasks(const std::vector<std::reference_w state.getZoom() ), program.computeAllAttributeBindings( - staticData.tileVertexBuffer, + *staticData.tileVertexBuffer, paintAttributeData, properties ), diff --git a/src/mbgl/renderer/paint_parameters.hpp b/src/mbgl/renderer/paint_parameters.hpp index 28db87ed4f..245f6704d2 100644 --- a/src/mbgl/renderer/paint_parameters.hpp +++ b/src/mbgl/renderer/paint_parameters.hpp @@ -7,7 +7,6 @@ #include <mbgl/gfx/stencil_mode.hpp> #include <mbgl/gfx/color_mode.hpp> #include <mbgl/util/mat4.hpp> -#include <mbgl/text/placement.hpp> #include <array> #include <map> @@ -41,8 +40,7 @@ public: const EvaluatedLight&, RenderStaticData&, ImageManager&, - LineAtlas&, - Placement::VariableOffsets); + LineAtlas&); ~PaintParameters(); gfx::Context& context; @@ -63,7 +61,6 @@ public: TimePoint timePoint; float pixelRatio; - Placement::VariableOffsets variableOffsets; std::array<float, 2> pixelsToGLUnits; Programs& programs; diff --git a/src/mbgl/renderer/paint_property_binder.hpp b/src/mbgl/renderer/paint_property_binder.hpp index a54cb8fc34..5cd75645f4 100644 --- a/src/mbgl/renderer/paint_property_binder.hpp +++ b/src/mbgl/renderer/paint_property_binder.hpp @@ -3,6 +3,7 @@ #include <mbgl/gfx/context.hpp> #include <mbgl/gfx/uniform.hpp> #include <mbgl/gfx/attribute.hpp> +#include <mbgl/gfx/upload_pass.hpp> #include <mbgl/programs/attributes.hpp> #include <mbgl/util/literal.hpp> #include <mbgl/util/type_list.hpp> @@ -99,7 +100,7 @@ public: std::size_t length, const ImagePositions&, const optional<PatternDependency>&, const style::expression::Value&) = 0; - virtual void upload(gfx::Context& context) = 0; + virtual void upload(gfx::UploadPass&) = 0; virtual void setPatternParameters(const optional<ImagePosition>&, const optional<ImagePosition>&, const CrossfadeParameters&) = 0; virtual std::tuple<ExpandToType<As, optional<gfx::AttributeBinding>>...> attributeBinding(const PossiblyEvaluatedType& currentValue) const = 0; virtual std::tuple<ExpandToType<As, float>...> interpolationFactor(float currentZoom) const = 0; @@ -118,7 +119,7 @@ public: } void populateVertexVector(const GeometryTileFeature&, std::size_t, const ImagePositions&, const optional<PatternDependency>&, const style::expression::Value&) override {} - void upload(gfx::Context&) override {} + void upload(gfx::UploadPass&) override {} void setPatternParameters(const optional<ImagePosition>&, const optional<ImagePosition>&, const CrossfadeParameters&) override {}; std::tuple<optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>&) const override { @@ -145,7 +146,7 @@ public: } void populateVertexVector(const GeometryTileFeature&, std::size_t, const ImagePositions&, const optional<PatternDependency>&, const style::expression::Value&) override {} - void upload(gfx::Context&) override {} + void upload(gfx::UploadPass&) override {} void setPatternParameters(const optional<ImagePosition>& posA, const optional<ImagePosition>& posB, const CrossfadeParameters&) override { if (!posA || !posB) { @@ -196,8 +197,8 @@ public: } } - void upload(gfx::Context& context) override { - vertexBuffer = context.createVertexBuffer(std::move(vertexVector)); + void upload(gfx::UploadPass& uploadPass) override { + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertexVector)); } std::tuple<optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>& currentValue) const override { @@ -260,8 +261,8 @@ public: } } - void upload(gfx::Context& context) override { - vertexBuffer = context.createVertexBuffer(std::move(vertexVector)); + void upload(gfx::UploadPass& uploadPass) override { + vertexBuffer = uploadPass.createVertexBuffer(std::move(vertexVector)); } std::tuple<optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>& currentValue) const override { @@ -352,10 +353,10 @@ public: } } - void upload(gfx::Context& context) override { - patternToVertexBuffer = context.createVertexBuffer(std::move(patternToVertexVector)); - zoomInVertexBuffer = context.createVertexBuffer(std::move(zoomInVertexVector)); - zoomOutVertexBuffer = context.createVertexBuffer(std::move(zoomOutVertexVector)); + void upload(gfx::UploadPass& uploadPass) override { + patternToVertexBuffer = uploadPass.createVertexBuffer(std::move(patternToVertexVector)); + zoomInVertexBuffer = uploadPass.createVertexBuffer(std::move(zoomInVertexVector)); + zoomOutVertexBuffer = uploadPass.createVertexBuffer(std::move(zoomOutVertexVector)); } std::tuple<optional<gfx::AttributeBinding>, optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<Faded<T>>& currentValue) const override { @@ -492,9 +493,9 @@ public: }); } - void upload(gfx::Context& context) { + void upload(gfx::UploadPass& uploadPass) { util::ignore({ - (binders.template get<Ps>()->upload(context), 0)... + (binders.template get<Ps>()->upload(uploadPass), 0)... }); } diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp index 2bc2563f52..8b01739c31 100644 --- a/src/mbgl/renderer/render_layer.hpp +++ b/src/mbgl/renderer/render_layer.hpp @@ -13,6 +13,7 @@ namespace mbgl { class Bucket; class TransitionParameters; class PropertyEvaluationParameters; +class UploadParameters; class PaintParameters; class RenderSource; class RenderLayerSymbolInterface; @@ -62,6 +63,7 @@ public: // Checks whether the given zoom is inside this layer zoom range. bool supportsZoom(float zoom) const; + virtual void upload(gfx::UploadPass&, UploadParameters&) {} virtual void render(PaintParameters&, RenderSource*) = 0; // Check wether the given geometry intersects diff --git a/src/mbgl/renderer/render_pass.hpp b/src/mbgl/renderer/render_pass.hpp index 5d18304129..ee0a846d7e 100644 --- a/src/mbgl/renderer/render_pass.hpp +++ b/src/mbgl/renderer/render_pass.hpp @@ -12,6 +12,7 @@ enum class RenderPass : uint8_t { Opaque = 1 << 0, Translucent = 1 << 1, Pass3D = 1 << 2, + Upload = 1 << 3, }; MBGL_CONSTEXPR RenderPass operator|(RenderPass a, RenderPass b) { diff --git a/src/mbgl/renderer/render_source.hpp b/src/mbgl/renderer/render_source.hpp index 89e7f095fa..2e433c01f9 100644 --- a/src/mbgl/renderer/render_source.hpp +++ b/src/mbgl/renderer/render_source.hpp @@ -27,6 +27,10 @@ class RenderSourceObserver; class TileParameters; class CollisionIndex; +namespace gfx { +class UploadPass; +} // namespace gfx + class RenderSource : protected TileObserver { public: static std::unique_ptr<RenderSource> create(Immutable<style::Source::Impl>); @@ -55,7 +59,8 @@ public: bool needsRelayout, const TileParameters&) = 0; - virtual void startRender(PaintParameters&) = 0; + virtual void upload(gfx::UploadPass&) = 0; + virtual void prepare(PaintParameters&) = 0; virtual void finishRender(PaintParameters&) = 0; // Returns a list of RenderTiles, sorted by tile id. diff --git a/src/mbgl/renderer/render_static_data.cpp b/src/mbgl/renderer/render_static_data.cpp index 0814d6341b..9090ef6579 100644 --- a/src/mbgl/renderer/render_static_data.cpp +++ b/src/mbgl/renderer/render_static_data.cpp @@ -1,5 +1,6 @@ #include <mbgl/renderer/render_static_data.hpp> #include <mbgl/gfx/context.hpp> +#include <mbgl/gfx/upload_pass.hpp> #include <mbgl/programs/program_parameters.hpp> namespace mbgl { @@ -49,12 +50,7 @@ static gfx::VertexVector<HeatmapTextureLayoutVertex> heatmapTextureVertices() { } RenderStaticData::RenderStaticData(gfx::Context& context, float pixelRatio, const optional<std::string>& programCacheDir) - : tileVertexBuffer(context.createVertexBuffer(tileVertices())), - rasterVertexBuffer(context.createVertexBuffer(rasterVertices())), - heatmapTextureVertexBuffer(context.createVertexBuffer(heatmapTextureVertices())), - quadTriangleIndexBuffer(context.createIndexBuffer(quadTriangleIndices())), - tileBorderIndexBuffer(context.createIndexBuffer(tileLineStripIndices())), - programs(context, ProgramParameters { pixelRatio, false, programCacheDir }) + : programs(context, ProgramParameters { pixelRatio, false, programCacheDir }) #ifndef NDEBUG , overdrawPrograms(context, ProgramParameters { pixelRatio, true, programCacheDir }) #endif @@ -65,4 +61,15 @@ RenderStaticData::RenderStaticData(gfx::Context& context, float pixelRatio, cons heatmapTextureSegments.emplace_back(0, 0, 4, 6); } +void RenderStaticData::upload(gfx::UploadPass& uploadPass) { + if (!uploaded) { + tileVertexBuffer = uploadPass.createVertexBuffer(tileVertices()); + rasterVertexBuffer = uploadPass.createVertexBuffer(rasterVertices()); + heatmapTextureVertexBuffer = uploadPass.createVertexBuffer(heatmapTextureVertices()); + quadTriangleIndexBuffer = uploadPass.createIndexBuffer(quadTriangleIndices()); + tileBorderIndexBuffer = uploadPass.createIndexBuffer(tileLineStripIndices()); + uploaded = true; + } +} + } // namespace mbgl diff --git a/src/mbgl/renderer/render_static_data.hpp b/src/mbgl/renderer/render_static_data.hpp index ddf52f83f6..5b409933af 100644 --- a/src/mbgl/renderer/render_static_data.hpp +++ b/src/mbgl/renderer/render_static_data.hpp @@ -14,18 +14,21 @@ namespace mbgl { namespace gfx { class Context; +class UploadPass; } // namespace gfx class RenderStaticData { public: RenderStaticData(gfx::Context&, float pixelRatio, const optional<std::string>& programCacheDir); - gfx::VertexBuffer<gfx::Vertex<PositionOnlyLayoutAttributes>> tileVertexBuffer; - gfx::VertexBuffer<RasterLayoutVertex> rasterVertexBuffer; - gfx::VertexBuffer<HeatmapTextureLayoutVertex> heatmapTextureVertexBuffer; + void upload(gfx::UploadPass&); - gfx::IndexBuffer quadTriangleIndexBuffer; - gfx::IndexBuffer tileBorderIndexBuffer; + optional<gfx::VertexBuffer<gfx::Vertex<PositionOnlyLayoutAttributes>>> tileVertexBuffer; + optional<gfx::VertexBuffer<RasterLayoutVertex>> rasterVertexBuffer; + optional<gfx::VertexBuffer<HeatmapTextureLayoutVertex>> heatmapTextureVertexBuffer; + + optional<gfx::IndexBuffer> quadTriangleIndexBuffer; + optional<gfx::IndexBuffer> tileBorderIndexBuffer; SegmentVector<BackgroundAttributes> tileTriangleSegments; SegmentVector<DebugAttributes> tileBorderSegments; @@ -34,6 +37,7 @@ public: optional<gfx::Renderbuffer<gfx::RenderbufferPixelType::Depth>> depthRenderbuffer; bool has3D = false; + bool uploaded = false; Size backendSize; Programs programs; diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp index 2c2a82a8a8..828163bd6e 100644 --- a/src/mbgl/renderer/render_tile.cpp +++ b/src/mbgl/renderer/render_tile.cpp @@ -12,6 +12,11 @@ namespace mbgl { using namespace style; +RenderTile::RenderTile(UnwrappedTileID id_, Tile& tile_) : id(std::move(id_)), tile(tile_) { +} + +RenderTile::~RenderTile() = default; + mat4 RenderTile::translateVtxMatrix(const mat4& tileMatrix, const std::array<float, 2>& translation, TranslateAnchorType anchor, @@ -57,8 +62,27 @@ void RenderTile::setMask(TileMask&& mask) { tile.setMask(std::move(mask)); } -void RenderTile::startRender(PaintParameters& parameters) { - tile.upload(parameters.context); +void RenderTile::upload(gfx::UploadPass& uploadPass) { + tile.upload(uploadPass); + + if (debugBucket) { + debugBucket->upload(uploadPass); + } +} + +void RenderTile::prepare(PaintParameters& parameters) { + if (parameters.debugOptions != MapDebugOptions::NoDebug && + (!debugBucket || debugBucket->renderable != tile.isRenderable() || + debugBucket->complete != tile.isComplete() || + !(debugBucket->modified == tile.modified) || + !(debugBucket->expires == tile.expires) || + debugBucket->debugMode != parameters.debugOptions)) { + debugBucket = std::make_unique<DebugBucket>( + tile.id, tile.isRenderable(), tile.isComplete(), tile.modified, tile.expires, + parameters.debugOptions); + } else if (parameters.debugOptions == MapDebugOptions::NoDebug) { + debugBucket.reset(); + } // Calculate two matrices for this tile: matrix is the standard tile matrix; nearClippedMatrix // clips the near plane to 100 to save depth buffer precision @@ -77,21 +101,10 @@ void RenderTile::finishRender(PaintParameters& parameters) { auto& program = parameters.programs.debug; - if (parameters.debugOptions != MapDebugOptions::NoDebug && - (!tile.debugBucket || tile.debugBucket->renderable != tile.isRenderable() || - tile.debugBucket->complete != tile.isComplete() || - !(tile.debugBucket->modified == tile.modified) || - !(tile.debugBucket->expires == tile.expires) || - tile.debugBucket->debugMode != parameters.debugOptions)) { - tile.debugBucket = std::make_unique<DebugBucket>( - tile.id, tile.isRenderable(), tile.isComplete(), tile.modified, tile.expires, - parameters.debugOptions, parameters.context); - } - if (parameters.debugOptions & (MapDebugOptions::Timestamps | MapDebugOptions::ParseStatus)) { - assert(tile.debugBucket); + assert(debugBucket); const auto allAttributeBindings = program.computeAllAttributeBindings( - *tile.debugBucket->vertexBuffer, + *debugBucket->vertexBuffer, paintAttributeData, properties ); @@ -104,8 +117,8 @@ void RenderTile::finishRender(PaintParameters& parameters) { gfx::StencilMode::disabled(), gfx::ColorMode::unblended(), gfx::CullFaceMode::disabled(), - *tile.debugBucket->indexBuffer, - tile.debugBucket->segments, + *debugBucket->indexBuffer, + debugBucket->segments, program.computeAllUniformValues( DebugProgram::LayoutUniformValues { uniforms::matrix::Value( matrix ), @@ -117,7 +130,7 @@ void RenderTile::finishRender(PaintParameters& parameters) { ), allAttributeBindings, DebugProgram::TextureBindings{}, - "__debug/" + tile.debugBucket->drawScopeID + "/text-outline" + "__debug/" + debugBucket->drawScopeID + "/text-outline" ); program.draw( @@ -128,8 +141,8 @@ void RenderTile::finishRender(PaintParameters& parameters) { gfx::StencilMode::disabled(), gfx::ColorMode::unblended(), gfx::CullFaceMode::disabled(), - *tile.debugBucket->indexBuffer, - tile.debugBucket->segments, + *debugBucket->indexBuffer, + debugBucket->segments, program.computeAllUniformValues( DebugProgram::LayoutUniformValues { uniforms::matrix::Value( matrix ), @@ -141,12 +154,12 @@ void RenderTile::finishRender(PaintParameters& parameters) { ), allAttributeBindings, DebugProgram::TextureBindings{}, - "__debug/" + tile.debugBucket->drawScopeID + "/text" + "__debug/" + debugBucket->drawScopeID + "/text" ); } if (parameters.debugOptions & MapDebugOptions::TileBorders) { - assert(tile.debugBucket); + assert(debugBucket); parameters.programs.debug.draw( parameters.context, *parameters.renderPass, @@ -155,7 +168,7 @@ void RenderTile::finishRender(PaintParameters& parameters) { gfx::StencilMode::disabled(), gfx::ColorMode::unblended(), gfx::CullFaceMode::disabled(), - parameters.staticData.tileBorderIndexBuffer, + *parameters.staticData.tileBorderIndexBuffer, parameters.staticData.tileBorderSegments, program.computeAllUniformValues( DebugProgram::LayoutUniformValues { @@ -167,12 +180,12 @@ void RenderTile::finishRender(PaintParameters& parameters) { parameters.state.getZoom() ), program.computeAllAttributeBindings( - parameters.staticData.tileVertexBuffer, + *parameters.staticData.tileVertexBuffer, paintAttributeData, properties ), DebugProgram::TextureBindings{}, - "__debug/" + tile.debugBucket->drawScopeID + "__debug/" + debugBucket->drawScopeID ); } } diff --git a/src/mbgl/renderer/render_tile.hpp b/src/mbgl/renderer/render_tile.hpp index dbdae097ee..559f37a090 100644 --- a/src/mbgl/renderer/render_tile.hpp +++ b/src/mbgl/renderer/render_tile.hpp @@ -6,16 +6,23 @@ #include <mbgl/renderer/tile_mask.hpp> #include <array> +#include <memory> namespace mbgl { +namespace gfx { +class UploadPass; +} // namespace gfx + class Tile; class TransformState; class PaintParameters; +class DebugBucket; class RenderTile final { public: - RenderTile(UnwrappedTileID id_, Tile& tile_) : id(std::move(id_)), tile(tile_) {} + RenderTile(UnwrappedTileID, Tile&); + ~RenderTile(); RenderTile(const RenderTile&) = delete; RenderTile(RenderTile&&) = default; RenderTile& operator=(const RenderTile&) = delete; @@ -26,6 +33,8 @@ public: mat4 matrix; mat4 nearClippedMatrix; bool used = false; + // Contains the tile ID string for painting debug information. + std::unique_ptr<DebugBucket> debugBucket; mat4 translatedMatrix(const std::array<float, 2>& translate, style::TranslateAnchorType anchor, @@ -36,7 +45,8 @@ public: const TransformState&) const; void setMask(TileMask&&); - void startRender(PaintParameters&); + void upload(gfx::UploadPass&); + void prepare(PaintParameters&); void finishRender(PaintParameters&); mat4 translateVtxMatrix(const mat4& tileMatrix, diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp index 52a2342454..3f9b59a14a 100644 --- a/src/mbgl/renderer/renderer_impl.cpp +++ b/src/mbgl/renderer/renderer_impl.cpp @@ -6,6 +6,7 @@ #include <mbgl/renderer/render_layer.hpp> #include <mbgl/renderer/render_static_data.hpp> #include <mbgl/renderer/update_parameters.hpp> +#include <mbgl/renderer/upload_parameters.hpp> #include <mbgl/renderer/paint_parameters.hpp> #include <mbgl/renderer/transition_parameters.hpp> #include <mbgl/renderer/property_evaluation_parameters.hpp> @@ -16,6 +17,7 @@ #include <mbgl/gfx/backend_scope.hpp> #include <mbgl/renderer/image_manager.hpp> #include <mbgl/gfx/renderer_backend.hpp> +#include <mbgl/gfx/upload_pass.hpp> #include <mbgl/gfx/render_pass.hpp> #include <mbgl/gfx/cull_face_mode.hpp> #include <mbgl/gfx/context.hpp> @@ -347,8 +349,13 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) { } } + auto& context = backend.getContext(); + + // Blocks execution until the renderable is available. + backend.getDefaultRenderable().wait(); + PaintParameters parameters { - backend.getContext(), + context, pixelRatio, backend, updateParameters, @@ -356,25 +363,51 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) { *staticData, *imageManager, *lineAtlas, - placement->getVariableOffsets() }; parameters.symbolFadeChange = placement->symbolFadeChange(updateParameters.timePoint); + // TODO: move this pass to before the PaintParameters initialization + // - PREPARE PASS ------------------------------------------------------------------------------- + // Runs an initialization pass for all sources. + { + // Update all matrices and generate data that we should upload to the GPU. + for (const auto& entry : renderSources) { + if (entry.second->isEnabled()) { + entry.second->prepare(parameters); + } + } + } + // - UPLOAD PASS ------------------------------------------------------------------------------- // Uploads all required buffers and images before we do any actual rendering. { - const auto debugGroup(parameters.encoder->createDebugGroup("upload")); + const auto uploadPass = parameters.encoder->createUploadPass("upload"); - parameters.imageManager.upload(parameters.context); - parameters.lineAtlas.upload(parameters.context); - // Update all clipping IDs + upload buckets. for (const auto& entry : renderSources) { if (entry.second->isEnabled()) { - entry.second->startRender(parameters); + entry.second->upload(*uploadPass); } } + + UploadParameters uploadParameters{ + updateParameters.transformState, + placement->getVariableOffsets(), + *imageManager, + *lineAtlas, + }; + + for (auto& renderItem : renderItems) { + RenderLayer& renderLayer = renderItem.layer; + if (renderLayer.hasRenderPass(RenderPass::Upload)) { + renderLayer.upload(*uploadPass, uploadParameters); + } + } + + staticData->upload(*uploadPass); + imageManager->upload(*uploadPass); + lineAtlas->upload(*uploadPass); } // - 3D PASS ------------------------------------------------------------------------------------- diff --git a/src/mbgl/renderer/sources/render_custom_geometry_source.cpp b/src/mbgl/renderer/sources/render_custom_geometry_source.cpp index 8de79d8016..45d49ffa5b 100644 --- a/src/mbgl/renderer/sources/render_custom_geometry_source.cpp +++ b/src/mbgl/renderer/sources/render_custom_geometry_source.cpp @@ -47,8 +47,12 @@ void RenderCustomGeometrySource::update(Immutable<style::Source::Impl> baseImpl_ }); } -void RenderCustomGeometrySource::startRender(PaintParameters& parameters) { - tilePyramid.startRender(parameters); +void RenderCustomGeometrySource::upload(gfx::UploadPass& uploadPass) { + tilePyramid.upload(uploadPass); +} + +void RenderCustomGeometrySource::prepare(PaintParameters& parameters) { + tilePyramid.prepare(parameters); } void RenderCustomGeometrySource::finishRender(PaintParameters& parameters) { diff --git a/src/mbgl/renderer/sources/render_custom_geometry_source.hpp b/src/mbgl/renderer/sources/render_custom_geometry_source.hpp index be9e022eb9..485979bee9 100644 --- a/src/mbgl/renderer/sources/render_custom_geometry_source.hpp +++ b/src/mbgl/renderer/sources/render_custom_geometry_source.hpp @@ -18,7 +18,8 @@ public: bool needsRelayout, const TileParameters&) final; - void startRender(PaintParameters&) final; + void upload(gfx::UploadPass&) final; + void prepare(PaintParameters&) final; void finishRender(PaintParameters&) final; std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final; diff --git a/src/mbgl/renderer/sources/render_geojson_source.cpp b/src/mbgl/renderer/sources/render_geojson_source.cpp index 0234b97eca..7ff371620a 100644 --- a/src/mbgl/renderer/sources/render_geojson_source.cpp +++ b/src/mbgl/renderer/sources/render_geojson_source.cpp @@ -123,8 +123,12 @@ void RenderGeoJSONSource::update(Immutable<style::Source::Impl> baseImpl_, }); } -void RenderGeoJSONSource::startRender(PaintParameters& parameters) { - tilePyramid.startRender(parameters); +void RenderGeoJSONSource::upload(gfx::UploadPass& parameters) { + tilePyramid.upload(parameters); +} + +void RenderGeoJSONSource::prepare(PaintParameters& parameters) { + tilePyramid.prepare(parameters); } void RenderGeoJSONSource::finishRender(PaintParameters& parameters) { diff --git a/src/mbgl/renderer/sources/render_geojson_source.hpp b/src/mbgl/renderer/sources/render_geojson_source.hpp index c8e98f96ee..1a2ff55427 100644 --- a/src/mbgl/renderer/sources/render_geojson_source.hpp +++ b/src/mbgl/renderer/sources/render_geojson_source.hpp @@ -23,7 +23,8 @@ public: bool needsRelayout, const TileParameters&) final; - void startRender(PaintParameters&) final; + void upload(gfx::UploadPass&) final; + void prepare(PaintParameters&) final; void finishRender(PaintParameters&) final; std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final; diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp index b6a75acacc..e63c9ad15c 100644 --- a/src/mbgl/renderer/sources/render_image_source.cpp +++ b/src/mbgl/renderer/sources/render_image_source.cpp @@ -31,7 +31,13 @@ bool RenderImageSource::isLoaded() const { return !!bucket; } -void RenderImageSource::startRender(PaintParameters& parameters) { +void RenderImageSource::upload(gfx::UploadPass& uploadPass) { + if (bucket->needsUpload()) { + bucket->upload(uploadPass); + } +} + +void RenderImageSource::prepare(PaintParameters& parameters) { if (!isLoaded()) { return; } @@ -45,10 +51,6 @@ void RenderImageSource::startRender(PaintParameters& parameters) { matrix::multiply(matrix, parameters.alignedProjMatrix, matrix); matrices.push_back(matrix); } - - if (bucket->needsUpload()) { - bucket->upload(parameters.context); - } } void RenderImageSource::finishRender(PaintParameters& parameters) { @@ -70,7 +72,7 @@ void RenderImageSource::finishRender(PaintParameters& parameters) { gfx::StencilMode::disabled(), gfx::ColorMode::unblended(), gfx::CullFaceMode::disabled(), - parameters.staticData.tileBorderIndexBuffer, + *parameters.staticData.tileBorderIndexBuffer, parameters.staticData.tileBorderSegments, programInstance.computeAllUniformValues( DebugProgram::LayoutUniformValues { @@ -82,7 +84,7 @@ void RenderImageSource::finishRender(PaintParameters& parameters) { parameters.state.getZoom() ), programInstance.computeAllAttributeBindings( - parameters.staticData.tileVertexBuffer, + *parameters.staticData.tileVertexBuffer, paintAttributeData, properties ), diff --git a/src/mbgl/renderer/sources/render_image_source.hpp b/src/mbgl/renderer/sources/render_image_source.hpp index e5cdcd4d81..c07fd467cb 100644 --- a/src/mbgl/renderer/sources/render_image_source.hpp +++ b/src/mbgl/renderer/sources/render_image_source.hpp @@ -15,7 +15,8 @@ public: bool isLoaded() const final; - void startRender(PaintParameters&) final; + void upload(gfx::UploadPass&) final; + void prepare(PaintParameters&) final; void finishRender(PaintParameters&) final; void update(Immutable<style::Source::Impl>, diff --git a/src/mbgl/renderer/sources/render_raster_dem_source.cpp b/src/mbgl/renderer/sources/render_raster_dem_source.cpp index c942432e64..c9f17f38c4 100644 --- a/src/mbgl/renderer/sources/render_raster_dem_source.cpp +++ b/src/mbgl/renderer/sources/render_raster_dem_source.cpp @@ -126,9 +126,13 @@ void RenderRasterDEMSource::onTileChanged(Tile& tile){ RenderSource::onTileChanged(tile); } -void RenderRasterDEMSource::startRender(PaintParameters& parameters) { +void RenderRasterDEMSource::upload(gfx::UploadPass& parameters) { + tilePyramid.upload(parameters); +} + +void RenderRasterDEMSource::prepare(PaintParameters& parameters) { algorithm::updateTileMasks(tilePyramid.getRenderTiles()); - tilePyramid.startRender(parameters); + tilePyramid.prepare(parameters); } void RenderRasterDEMSource::finishRender(PaintParameters& parameters) { diff --git a/src/mbgl/renderer/sources/render_raster_dem_source.hpp b/src/mbgl/renderer/sources/render_raster_dem_source.hpp index af76e22da7..57180bb4e2 100644 --- a/src/mbgl/renderer/sources/render_raster_dem_source.hpp +++ b/src/mbgl/renderer/sources/render_raster_dem_source.hpp @@ -18,7 +18,8 @@ public: bool needsRelayout, const TileParameters&) final; - void startRender(PaintParameters&) final; + void upload(gfx::UploadPass&) final; + void prepare(PaintParameters&) final; void finishRender(PaintParameters&) final; std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final; diff --git a/src/mbgl/renderer/sources/render_raster_source.cpp b/src/mbgl/renderer/sources/render_raster_source.cpp index 96e793f9b2..39cccd47e6 100644 --- a/src/mbgl/renderer/sources/render_raster_source.cpp +++ b/src/mbgl/renderer/sources/render_raster_source.cpp @@ -57,9 +57,13 @@ void RenderRasterSource::update(Immutable<style::Source::Impl> baseImpl_, }); } -void RenderRasterSource::startRender(PaintParameters& parameters) { +void RenderRasterSource::upload(gfx::UploadPass& parameters) { + tilePyramid.upload(parameters); +} + +void RenderRasterSource::prepare(PaintParameters& parameters) { algorithm::updateTileMasks(tilePyramid.getRenderTiles()); - tilePyramid.startRender(parameters); + tilePyramid.prepare(parameters); } void RenderRasterSource::finishRender(PaintParameters& parameters) { diff --git a/src/mbgl/renderer/sources/render_raster_source.hpp b/src/mbgl/renderer/sources/render_raster_source.hpp index 24242949bb..e399893cb9 100644 --- a/src/mbgl/renderer/sources/render_raster_source.hpp +++ b/src/mbgl/renderer/sources/render_raster_source.hpp @@ -18,7 +18,8 @@ public: bool needsRelayout, const TileParameters&) final; - void startRender(PaintParameters&) final; + void upload(gfx::UploadPass&) final; + void prepare(PaintParameters&) final; void finishRender(PaintParameters&) final; std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final; diff --git a/src/mbgl/renderer/sources/render_vector_source.cpp b/src/mbgl/renderer/sources/render_vector_source.cpp index 518692fc77..21b728e266 100644 --- a/src/mbgl/renderer/sources/render_vector_source.cpp +++ b/src/mbgl/renderer/sources/render_vector_source.cpp @@ -57,8 +57,12 @@ void RenderVectorSource::update(Immutable<style::Source::Impl> baseImpl_, }); } -void RenderVectorSource::startRender(PaintParameters& parameters) { - tilePyramid.startRender(parameters); +void RenderVectorSource::upload(gfx::UploadPass& parameters) { + tilePyramid.upload(parameters); +} + +void RenderVectorSource::prepare(PaintParameters& parameters) { + tilePyramid.prepare(parameters); } void RenderVectorSource::finishRender(PaintParameters& parameters) { diff --git a/src/mbgl/renderer/sources/render_vector_source.hpp b/src/mbgl/renderer/sources/render_vector_source.hpp index fe7147fc25..bea9bad20e 100644 --- a/src/mbgl/renderer/sources/render_vector_source.hpp +++ b/src/mbgl/renderer/sources/render_vector_source.hpp @@ -18,7 +18,8 @@ public: bool needsRelayout, const TileParameters&) final; - void startRender(PaintParameters&) final; + void upload(gfx::UploadPass&) final; + void prepare(PaintParameters&) final; void finishRender(PaintParameters&) final; std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final; diff --git a/src/mbgl/renderer/tile_pyramid.cpp b/src/mbgl/renderer/tile_pyramid.cpp index 32b3ef0dba..36ac0162e6 100644 --- a/src/mbgl/renderer/tile_pyramid.cpp +++ b/src/mbgl/renderer/tile_pyramid.cpp @@ -40,9 +40,15 @@ bool TilePyramid::isLoaded() const { return true; } -void TilePyramid::startRender(PaintParameters& parameters) { +void TilePyramid::upload(gfx::UploadPass& parameters) { for (auto& tile : renderTiles) { - tile.startRender(parameters); + tile.upload(parameters); + } +} + +void TilePyramid::prepare(PaintParameters& parameters) { + for (auto& tile : renderTiles) { + tile.prepare(parameters); } } diff --git a/src/mbgl/renderer/tile_pyramid.hpp b/src/mbgl/renderer/tile_pyramid.hpp index 98eafc39e6..c912a669ff 100644 --- a/src/mbgl/renderer/tile_pyramid.hpp +++ b/src/mbgl/renderer/tile_pyramid.hpp @@ -43,7 +43,8 @@ public: optional<LatLngBounds> bounds, std::function<std::unique_ptr<Tile> (const OverscaledTileID&)> createTile); - void startRender(PaintParameters&); + void upload(gfx::UploadPass&); + void prepare(PaintParameters&); void finishRender(PaintParameters&); std::vector<std::reference_wrapper<RenderTile>> getRenderTiles(); diff --git a/src/mbgl/renderer/upload_parameters.hpp b/src/mbgl/renderer/upload_parameters.hpp new file mode 100644 index 0000000000..0328309927 --- /dev/null +++ b/src/mbgl/renderer/upload_parameters.hpp @@ -0,0 +1,31 @@ +#pragma once + +#include <unordered_map> +#include <cstdint> + +namespace mbgl { + +class TransformState; +class LineAtlas; +class VariableOffset; +using VariableOffsets = std::unordered_map<uint32_t, VariableOffset>; + +class UploadParameters { +public: + UploadParameters(const TransformState& state_, + const VariableOffsets& variableOffsets_, + ImageManager& imageManager_, + LineAtlas& lineAtlas_) + : state(state_), + variableOffsets(variableOffsets_), + imageManager(imageManager_), + lineAtlas(lineAtlas_) { + } + + const TransformState& state; + const VariableOffsets& variableOffsets; + ImageManager& imageManager; + LineAtlas& lineAtlas; +}; + +} // namespace mbgl |