upload symbol opacity buffers in main upload pass [skip ci]upstream/start-collision-upload-pass

5 files changed, 81 insertions, 34 deletions

diff --git a/src/mbgl/renderer/buckets/symbol_bucket.cpp b/src/mbgl/renderer/buckets/symbol_bucket.cpp
index a544394353..592c29eb15 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.cpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.cpp
@@ -38,37 +38,78 @@ SymbolBucket::SymbolBucket(style::SymbolLayoutProperties::PossiblyEvaluated layo
 
 void SymbolBucket::upload(gl::Context& context) {
     if (hasTextData()) {
-        text.vertexBuffer = context.createVertexBuffer(std::move(text.vertices));
-        text.dynamicVertexBuffer = context.createVertexBuffer(std::move(text.dynamicVertices), gl::BufferUsage::StreamDraw);
-        text.opacityVertexBuffer = context.createVertexBuffer(std::move(text.opacityVertices), gl::BufferUsage::StreamDraw);
-        text.indexBuffer = context.createIndexBuffer(std::move(text.triangles));
+        if (!staticUploaded) {
+            text.indexBuffer = context.createIndexBuffer(std::move(text.triangles));
+            text.vertexBuffer = context.createVertexBuffer(std::move(text.vertices));
+        }
+        if (!dynamicUploaded) {
+            text.dynamicVertexBuffer = context.createVertexBuffer(std::move(text.dynamicVertices), gl::BufferUsage::StreamDraw);
+        }
+        if (!opacityUploaded) {
+            if (!text.opacityVertexBuffer) {
+                text.opacityVertexBuffer = context.createVertexBuffer(std::move(text.opacityVertices), gl::BufferUsage::StreamDraw);
+            } else {
+                context.updateVertexBuffer(*text.opacityVertexBuffer, std::move(text.opacityVertices));
+            }
+        }
     }
 
     if (hasIconData()) {
-        icon.vertexBuffer = context.createVertexBuffer(std::move(icon.vertices));
-        icon.dynamicVertexBuffer = context.createVertexBuffer(std::move(icon.dynamicVertices), gl::BufferUsage::StreamDraw);
-        icon.opacityVertexBuffer = context.createVertexBuffer(std::move(icon.opacityVertices), gl::BufferUsage::StreamDraw);
-        icon.indexBuffer = context.createIndexBuffer(std::move(icon.triangles));
+        if (!staticUploaded) {
+            icon.indexBuffer = context.createIndexBuffer(std::move(icon.triangles));
+            icon.vertexBuffer = context.createVertexBuffer(std::move(icon.vertices));
+        }
+        if (!dynamicUploaded) {
+            icon.dynamicVertexBuffer = context.createVertexBuffer(std::move(icon.dynamicVertices), gl::BufferUsage::StreamDraw);
+        }
+        if (!opacityUploaded) {
+            if (!icon.opacityVertexBuffer) {
+                icon.opacityVertexBuffer = context.createVertexBuffer(std::move(icon.opacityVertices), gl::BufferUsage::StreamDraw);
+            } else {
+                context.updateVertexBuffer(*icon.opacityVertexBuffer, std::move(icon.opacityVertices));
+            }
+        }
     }
 
     if (hasCollisionBoxData()) {
-        collisionBox.vertexBuffer = context.createVertexBuffer(std::move(collisionBox.vertices));
-        collisionBox.opacityVertexBuffer = context.createVertexBuffer(std::move(collisionBox.opacityVertices), gl::BufferUsage::StreamDraw);
-        collisionBox.indexBuffer = context.createIndexBuffer(std::move(collisionBox.lines));
+        if (!staticUploaded) {
+            collisionBox.indexBuffer = context.createIndexBuffer(std::move(collisionBox.lines));
+            collisionBox.vertexBuffer = context.createVertexBuffer(std::move(collisionBox.vertices));
+        }
+        if (!opacityUploaded) {
+            if (!collisionBox.opacityVertexBuffer) {
+                collisionBox.opacityVertexBuffer = context.createVertexBuffer(std::move(collisionBox.opacityVertices), gl::BufferUsage::StreamDraw);
+            } else {
+                context.updateVertexBuffer(*collisionBox.opacityVertexBuffer, std::move(collisionBox.opacityVertices));
+            }
+        }
     }
     
     if (hasCollisionCircleData()) {
-        collisionCircle.vertexBuffer = context.createVertexBuffer(std::move(collisionCircle.vertices));
-        collisionCircle.opacityVertexBuffer = context.createVertexBuffer(std::move(collisionCircle.opacityVertices), gl::BufferUsage::StreamDraw);
-        collisionCircle.indexBuffer = context.createIndexBuffer(std::move(collisionCircle.triangles));
+        if (!staticUploaded) {
+            collisionCircle.indexBuffer = context.createIndexBuffer(std::move(collisionCircle.triangles));
+            collisionCircle.vertexBuffer = context.createVertexBuffer(std::move(collisionCircle.vertices));
+        }
+        if (!opacityUploaded) {
+            if (!collisionCircle.opacityVertexBuffer) {
+                collisionCircle.opacityVertexBuffer = context.createVertexBuffer(std::move(collisionCircle.opacityVertices), gl::BufferUsage::StreamDraw);
+            } else {
+                context.updateVertexBuffer(*collisionCircle.opacityVertexBuffer, std::move(collisionCircle.opacityVertices));
+            }
+        }
     }
 
-    for (auto& pair : paintPropertyBinders) {
-        pair.second.first.upload(context);
-        pair.second.second.upload(context);
+    if (!staticUploaded) {
+        for (auto& pair : paintPropertyBinders) {
+            pair.second.first.upload(context);
+            pair.second.second.upload(context);
+        }
     }
 
     uploaded = true;
+    staticUploaded = true;
+    opacityUploaded = true;
+    dynamicUploaded = true;
 }
 
 bool SymbolBucket::hasData() const {
@@ -91,4 +132,9 @@ bool SymbolBucket::hasCollisionCircleData() const {
     return !collisionCircle.segments.empty();
 }
 
+void SymbolBucket::updateOpacity() {
+    opacityUploaded = false;
+    uploaded = false;
+}
+
 } // namespace mbgl
diff --git a/src/mbgl/renderer/buckets/symbol_bucket.hpp b/src/mbgl/renderer/buckets/symbol_bucket.hpp
index 0e797539e1..c2292d45f1 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.hpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.hpp
@@ -59,11 +59,16 @@ public:
     bool hasIconData() const;
     bool hasCollisionBoxData() const;
     bool hasCollisionCircleData() const;
+    void updateOpacity();
 
     const style::SymbolLayoutProperties::PossiblyEvaluated layout;
     const bool sdfIcons;
     const bool iconsNeedLinear;
 
+    bool staticUploaded = false;
+    bool opacityUploaded = false;
+    bool dynamicUploaded = false;
+
     std::vector<SymbolInstance> symbolInstances;
 
     std::map<std::string, std::pair<
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index ca4bda721f..cfb6a14dea 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -376,6 +376,13 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
     if (placementChanged) placement = std::move(newPlacement);
     parameters.symbolFadeChange = placement->symbolFadeChange(parameters.timePoint);
 
+    // TODO only update when necessary
+    for (auto it = order.rbegin(); it != order.rend(); ++it) {
+        if (it->layer.is<RenderSymbolLayer>()) {
+            placement->updateLayerOpacities(*it->layer.as<RenderSymbolLayer>());
+        }
+    }
+
     // - UPLOAD PASS -------------------------------------------------------------------------------
     // Uploads all required buffers and images before we do any actual rendering.
     {
@@ -392,14 +399,6 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         }
     }
 
-    // TODO only update when necessary
-    // TODO move this before the upload pass and use upload pass to update buffers
-    for (auto it = order.rbegin(); it != order.rend(); ++it) {
-        if (it->layer.is<RenderSymbolLayer>()) {
-            placement->updateLayerOpacities(*it->layer.as<RenderSymbolLayer>(), parameters.context);
-        }
-    }
-
     // - 3D PASS -------------------------------------------------------------------------------------
     // Renders any 3D layers bottom-to-top to unique FBOs with texture attachments, but share the same
     // depth rbo between them.
diff --git a/src/mbgl/text/placement.cpp b/src/mbgl/text/placement.cpp
index c4633a2205..b63fcf51b9 100644
--- a/src/mbgl/text/placement.cpp
+++ b/src/mbgl/text/placement.cpp
@@ -186,7 +186,7 @@ bool Placement::commit(const Placement& prevPlacement, TimePoint now) {
     return placementChanged;
 }
 
-void Placement::updateLayerOpacities(RenderSymbolLayer& symbolLayer, gl::Context& context) {
+void Placement::updateLayerOpacities(RenderSymbolLayer& symbolLayer) {
     for (RenderTile& renderTile : symbolLayer.renderTiles) {
         if (!renderTile.tile.isRenderable()) {
             continue;
@@ -195,11 +195,11 @@ void Placement::updateLayerOpacities(RenderSymbolLayer& symbolLayer, gl::Context
         auto bucket = renderTile.tile.getBucket(*symbolLayer.baseImpl);
         assert(dynamic_cast<SymbolBucket*>(bucket));
         SymbolBucket& symbolBucket = *reinterpret_cast<SymbolBucket*>(bucket);
-        updateBucketOpacities(symbolBucket, context);
+        updateBucketOpacities(symbolBucket);
     }
 }
 
-void Placement::updateBucketOpacities(SymbolBucket& bucket, gl::Context& context) {
+void Placement::updateBucketOpacities(SymbolBucket& bucket) {
     // TODO check if this clear is necessary, whether the vector has been moved out
     if (bucket.hasTextData()) bucket.text.opacityVertices.clear();
     if (bucket.hasIconData()) bucket.icon.opacityVertices.clear();
@@ -249,10 +249,7 @@ void Placement::updateBucketOpacities(SymbolBucket& bucket, gl::Context& context
         updateCollisionBox(symbolInstance.iconCollisionFeature, opacityState.icon.placed);
     }
 
-    if (bucket.hasTextData()) context.updateVertexBuffer(*bucket.text.opacityVertexBuffer, std::move(bucket.text.opacityVertices));
-    if (bucket.hasIconData()) context.updateVertexBuffer(*bucket.icon.opacityVertexBuffer, std::move(bucket.icon.opacityVertices));
-    if (bucket.hasCollisionBoxData()) context.updateVertexBuffer(*bucket.collisionBox.opacityVertexBuffer, std::move(bucket.collisionBox.opacityVertices));
-    if (bucket.hasCollisionCircleData()) context.updateVertexBuffer(*bucket.collisionCircle.opacityVertexBuffer, std::move(bucket.collisionCircle.opacityVertices));
+    bucket.updateOpacity();
 }
 
 JointOpacityState Placement::getOpacity(uint32_t crossTileSymbolID) const {
diff --git a/src/mbgl/text/placement.hpp b/src/mbgl/text/placement.hpp
index 1fbd71caf5..7e08301bf2 100644
--- a/src/mbgl/text/placement.hpp
+++ b/src/mbgl/text/placement.hpp
@@ -41,7 +41,7 @@ namespace mbgl {
             Placement(const TransformState&);
             void placeLayer(RenderSymbolLayer&, bool showCollisionBoxes);
             bool commit(const Placement& prevPlacement, TimePoint);
-            void updateLayerOpacities(RenderSymbolLayer&, gl::Context&);
+            void updateLayerOpacities(RenderSymbolLayer&);
             JointOpacityState getOpacity(uint32_t crossTileSymbolID) const;
             float symbolFadeChange(TimePoint now) const;
             bool hasTransitions(TimePoint now) const;
@@ -56,7 +56,7 @@ namespace mbgl {
                     const float scale,
                     const bool showCollisionBoxes);
 
-            void updateBucketOpacities(SymbolBucket&, gl::Context&);
+            void updateBucketOpacities(SymbolBucket&);
 
             CollisionIndex collisionIndex;
             TransformState state;