From bc514eaa3210a5dd22707cfdf0eaa89774cb6790 Mon Sep 17 00:00:00 2001
From: "r.kuznetsov" <r.kuznetsov@corp.mail.ru>
Date: Thu, 11 Feb 2016 18:54:04 +0300
Subject: [PATCH] Overlay tree optimization

---
 drape/overlay_handle.cpp              |  42 +++++---
 drape/overlay_handle.hpp              |  13 ++-
 drape/overlay_tree.cpp                | 136 ++++++++++++++++----------
 drape/overlay_tree.hpp                |  12 ++-
 drape/render_bucket.cpp               |  10 +-
 drape/render_bucket.hpp               |   3 +-
 drape_frontend/frontend_renderer.cpp  |  80 ++++-----------
 drape_frontend/frontend_renderer.hpp  |   2 +-
 drape_frontend/gps_track_renderer.cpp |   2 +-
 drape_frontend/gps_track_shape.cpp    |   5 +-
 drape_frontend/gps_track_shape.hpp    |   3 +-
 drape_frontend/gui/gui_text.cpp       |   5 +-
 drape_frontend/gui/gui_text.hpp       |   3 +-
 drape_frontend/gui/shape.cpp          |   2 +-
 drape_frontend/path_text_shape.cpp    |   5 +-
 drape_frontend/render_group.cpp       |  19 ++--
 drape_frontend/render_group.hpp       |   3 +-
 drape_frontend/route_renderer.cpp     |   6 +-
 drape_frontend/text_handle.cpp        |   5 +-
 drape_frontend/text_handle.hpp        |   3 +-
 drape_head/testing_engine.cpp         |   2 +-
 21 files changed, 186 insertions(+), 175 deletions(-)

diff --git a/drape/overlay_handle.cpp b/drape/overlay_handle.cpp
index d656048c6e..761da448fd 100644
--- a/drape/overlay_handle.cpp
+++ b/drape/overlay_handle.cpp
@@ -34,7 +34,16 @@ OverlayHandle::OverlayHandle(FeatureID const & id,
   , m_pivotZ(0.0)
   , m_isBillboard(isBillboard)
   , m_isVisible(false)
+  , m_enableCaching(false)
+  , m_extendedRectsDirty(true)
+  , m_extendedRectDirty(true)
+{}
+
+void OverlayHandle::SetCachingEnable(bool enable)
 {
+  m_enableCaching = enable;
+  m_extendedRectsDirty = true;
+  m_extendedRectDirty = true;
 }
 
 bool OverlayHandle::IsVisible() const
@@ -76,11 +85,8 @@ m2::PointD OverlayHandle::GetPivot(ScreenBase const & screen, bool perspective)
 
 bool OverlayHandle::IsIntersect(ScreenBase const & screen, ref_ptr<OverlayHandle> const h) const
 {
-  Rects ar1;
-  Rects ar2;
-
-  GetExtendedPixelShape(screen, ar1);
-  h->GetExtendedPixelShape(screen, ar2);
+  Rects const & ar1 = GetExtendedPixelShape(screen);
+  Rects const & ar2 = h->GetExtendedPixelShape(screen);
 
   for (size_t i = 0; i < ar1.size(); ++i)
     for (size_t j = 0; j < ar2.size(); ++j)
@@ -102,11 +108,9 @@ void OverlayHandle::GetElementIndexes(ref_ptr<IndexBufferMutator> mutator) const
   mutator->AppendIndexes(m_indexes.GetRawConst(), m_indexes.Size());
 }
 
-void OverlayHandle::GetAttributeMutation(ref_ptr<AttributeBufferMutator> mutator,
-                                         ScreenBase const & screen) const
+void OverlayHandle::GetAttributeMutation(ref_ptr<AttributeBufferMutator> mutator) const
 {
   UNUSED_VALUE(mutator);
-  UNUSED_VALUE(screen);
 }
 
 bool OverlayHandle::HasDynamicAttributes() const
@@ -140,16 +144,26 @@ OverlayHandle::TOffsetNode const & OverlayHandle::GetOffsetNode(uint8_t bufferID
 
 m2::RectD OverlayHandle::GetExtendedPixelRect(ScreenBase const & screen) const
 {
-  m2::RectD rect = GetPixelRect(screen, screen.isPerspective());
-  rect.Inflate(m_extendingSize, m_extendingSize);
-  return rect;
+  if (m_enableCaching && !m_extendedRectDirty)
+    return m_extendedRectCache;
+
+  m_extendedRectCache = GetPixelRect(screen, screen.isPerspective());
+  m_extendedRectCache.Inflate(m_extendingSize, m_extendingSize);
+  m_extendedRectDirty = false;
+  return m_extendedRectCache;
 }
 
-void OverlayHandle::GetExtendedPixelShape(ScreenBase const & screen, Rects & rects) const
+OverlayHandle::Rects const & OverlayHandle::GetExtendedPixelShape(ScreenBase const & screen) const
 {
-  GetPixelShape(screen, rects, screen.isPerspective());
-  for (auto & rect : rects)
+  if (m_enableCaching && !m_extendedRectsDirty)
+    return m_extendedRectsCache;
+
+  m_extendedRectsCache.clear();
+  GetPixelShape(screen, m_extendedRectsCache, screen.isPerspective());
+  for (auto & rect : m_extendedRectsCache)
     rect.Inflate(m_extendingSize, m_extendingSize);
+  m_extendedRectsDirty = false;
+  return m_extendedRectsCache;
 }
 
 m2::RectD OverlayHandle::GetPerspectiveRect(m2::RectD const & pixelRect, ScreenBase const & screen) const
diff --git a/drape/overlay_handle.hpp b/drape/overlay_handle.hpp
index 0553891a60..83874ba4ba 100644
--- a/drape/overlay_handle.hpp
+++ b/drape/overlay_handle.hpp
@@ -64,15 +64,14 @@ public:
   double GetExtendingSize() const { return m_extendingSize; }
   void SetExtendingSize(double extendingSize) { m_extendingSize = extendingSize; }
   m2::RectD GetExtendedPixelRect(ScreenBase const & screen) const;
-  void GetExtendedPixelShape(ScreenBase const & screen, Rects & rects) const;
+  Rects const & GetExtendedPixelShape(ScreenBase const & screen) const;
 
   bool IsIntersect(ScreenBase const & screen, ref_ptr<OverlayHandle> const h) const;
 
   virtual bool IndexesRequired() const { return true; }
   void * IndexStorage(uint32_t size);
   void GetElementIndexes(ref_ptr<IndexBufferMutator> mutator) const;
-  virtual void GetAttributeMutation(ref_ptr<AttributeBufferMutator> mutator,
-                                    ScreenBase const & screen) const;
+  virtual void GetAttributeMutation(ref_ptr<AttributeBufferMutator> mutator) const;
 
   bool HasDynamicAttributes() const;
   void AddDynamicAttribute(BindingInfo const & binding, uint32_t offset, uint32_t count);
@@ -90,6 +89,8 @@ public:
   int GetOverlayRank() const { return m_overlayRank; }
   void SetOverlayRank(int overlayRank) { m_overlayRank = overlayRank; }
 
+  void SetCachingEnable(bool enable);
+
 #ifdef DEBUG_OVERLAYS_OUTPUT
   virtual string GetOverlayDebugInfo() { return ""; }
 #endif
@@ -125,6 +126,12 @@ private:
   struct OffsetNodeFinder;
 
   set<TOffsetNode, LessOffsetNode> m_offsets;
+
+  bool m_enableCaching;
+  mutable Rects m_extendedRectsCache;
+  mutable bool m_extendedRectsDirty;
+  mutable m2::RectD m_extendedRectCache;
+  mutable bool m_extendedRectDirty;
 };
 
 class SquareHandle : public OverlayHandle
diff --git a/drape/overlay_tree.cpp b/drape/overlay_tree.cpp
index b27bc4074c..cfc3fd401d 100644
--- a/drape/overlay_tree.cpp
+++ b/drape/overlay_tree.cpp
@@ -7,7 +7,6 @@ namespace dp
 {
 
 int const kFrameUpdarePeriod = 10;
-int const kFrameUpdarePeriodIn3d = 30;
 int const kAverageHandlesCount[dp::OverlayRanksCount] = { 300, 200, 50 };
 
 namespace
@@ -67,13 +66,13 @@ OverlayTree::OverlayTree()
     m_handles[i].reserve(kAverageHandlesCount[i]);
 }
 
-bool OverlayTree::Frame(bool is3d)
+bool OverlayTree::Frame()
 {
   if (IsNeedUpdate())
     return true;
 
   m_frameCounter++;
-  if (m_frameCounter >= (is3d ? kFrameUpdarePeriodIn3d : kFrameUpdarePeriod))
+  if (m_frameCounter >= kFrameUpdarePeriod)
     m_frameCounter = -1;
 
   return IsNeedUpdate();
@@ -84,15 +83,11 @@ bool OverlayTree::IsNeedUpdate() const
   return m_frameCounter == -1;
 }
 
-void OverlayTree::ForceUpdate()
-{
-  m_frameCounter = -1;
-}
-
 void OverlayTree::StartOverlayPlacing(ScreenBase const & screen)
 {
   ASSERT(IsNeedUpdate(), ());
   Clear();
+  m_handlesCache.clear();
   m_traits.m_modelView = screen;
 
 #ifdef COLLECT_DISPLACEMENT_INFO
@@ -100,6 +95,15 @@ void OverlayTree::StartOverlayPlacing(ScreenBase const & screen)
 #endif
 }
 
+void OverlayTree::Remove(ref_ptr<OverlayHandle> handle)
+{
+  if (m_frameCounter == -1)
+    return;
+
+  if (m_handlesCache.find(GetHandleKey(handle)) != m_handlesCache.end())
+    m_frameCounter = -1;
+}
+
 void OverlayTree::Add(ref_ptr<OverlayHandle> handle)
 {
   ASSERT(IsNeedUpdate(), ());
@@ -107,6 +111,10 @@ void OverlayTree::Add(ref_ptr<OverlayHandle> handle)
   ScreenBase const & modelView = GetModelView();
 
   handle->SetIsVisible(false);
+  handle->SetCachingEnable(true);
+
+  if (m_handlesCache.find(GetHandleKey(handle)) != m_handlesCache.end())
+    return;
 
   if (!handle->Update(modelView))
     return;
@@ -191,7 +199,7 @@ void OverlayTree::InsertHandle(ref_ptr<OverlayHandle> handle,
       // Handle is displaced and bound to its parent, parent will be displaced too.
       if (boundToParent)
       {
-        Erase(parentOverlay);
+        DeleteHandle(parentOverlay);
 
       #ifdef DEBUG_OVERLAYS_OUTPUT
         LOG(LINFO, ("Displace (0):", handle->GetOverlayDebugInfo(), "->", parentOverlay->GetOverlayDebugInfo()));
@@ -219,25 +227,51 @@ void OverlayTree::InsertHandle(ref_ptr<OverlayHandle> handle,
 
   // Current overlay displaces other overlay, delete them.
   for (auto const & rivalHandle : rivals)
-    AddHandleToDelete(rivalHandle);
-
-  for (auto const & handleToDelete : m_handlesToDelete)
   {
-    Erase(handleToDelete);
+    if (rivalHandle->IsBound())
+    {
+      // Delete rival handle and all handles bound to it.
+      for (auto it = m_handlesCache.begin(); it != m_handlesCache.end();)
+      {
+        if (it->second->GetFeatureID() == rivalHandle->GetFeatureID())
+        {
+          Erase(it->second);
 
-  #ifdef DEBUG_OVERLAYS_OUTPUT
-    LOG(LINFO, ("Displace (2):", handle->GetOverlayDebugInfo(), "->", handleToDelete->GetOverlayDebugInfo()));
-  #endif
+        #ifdef DEBUG_OVERLAYS_OUTPUT
+          LOG(LINFO, ("Displace (2):", handle->GetOverlayDebugInfo(), "->", it->second->GetOverlayDebugInfo()));
+        #endif
 
-  #ifdef COLLECT_DISPLACEMENT_INFO
-    m_displacementInfo.emplace_back(DisplacementData(handle->GetExtendedPixelRect(modelView).Center(),
-                                                     handleToDelete->GetExtendedPixelRect(modelView).Center(),
-                                                     dp::Color(0, 0, 255, 255)));
-  #endif
+        #ifdef COLLECT_DISPLACEMENT_INFO
+          m_displacementInfo.emplace_back(DisplacementData(handle->GetExtendedPixelRect(modelView).Center(),
+                                                           it->second->GetExtendedPixelRect(modelView).Center(),
+                                                           dp::Color(0, 0, 255, 255)));
+        #endif
+
+          it = m_handlesCache.erase(it);
+        }
+        else
+        {
+          ++it;
+        }
+      }
+    }
+    else
+    {
+      DeleteHandle(rivalHandle);
+
+    #ifdef DEBUG_OVERLAYS_OUTPUT
+      LOG(LINFO, ("Displace (3):", handle->GetOverlayDebugInfo(), "->", handleToDelete->GetOverlayDebugInfo()));
+    #endif
+
+    #ifdef COLLECT_DISPLACEMENT_INFO
+      m_displacementInfo.emplace_back(DisplacementData(handle->GetExtendedPixelRect(modelView).Center(),
+                                                       rivalHandle->GetExtendedPixelRect(modelView).Center(),
+                                                       dp::Color(0, 0, 255, 255)));
+    #endif
+    }
   }
 
-  m_handlesToDelete.clear();
-
+  m_handlesCache.insert(make_pair(GetHandleKey(handle), handle));
   TBase::Add(handle, pixelRect);
 }
 
@@ -266,10 +300,11 @@ void OverlayTree::EndOverlayPlacing()
     m_handles[rank].clear();
   }
 
-  ForEach([] (ref_ptr<OverlayHandle> const & h)
+  for (auto it = m_handlesCache.begin(); it != m_handlesCache.end(); ++it)
   {
-    h->SetIsVisible(true);
-  });
+    it->second->SetIsVisible(true);
+    it->second->SetCachingEnable(false);
+  }
 
   m_frameCounter = 0;
 
@@ -285,37 +320,30 @@ bool OverlayTree::CheckHandle(ref_ptr<OverlayHandle> handle, int currentRank,
     return true;
 
   int const seachingRank = currentRank - 1;
-  return FindNode([&](ref_ptr<OverlayHandle> const & h) -> bool
+  for (auto it = m_handlesCache.begin(); it != m_handlesCache.end(); ++it)
   {
-    if (h->GetFeatureID() == handle->GetFeatureID() && h->GetOverlayRank() == seachingRank)
+    if (it->second->GetFeatureID() == handle->GetFeatureID() &&
+        it->second->GetOverlayRank() == seachingRank)
     {
-      parentOverlay = h;
+      parentOverlay = it->second;
       return true;
     }
-    return false;
-  });
+  }
+
+  return false;
 }
 
-void OverlayTree::AddHandleToDelete(ref_ptr<OverlayHandle> const & handle)
+void OverlayTree::DeleteHandle(ref_ptr<OverlayHandle> const & handle)
 {
-  if (handle->IsBound())
-  {
-    ForEach([&](ref_ptr<OverlayHandle> const & h)
-    {
-      if (h->GetFeatureID() == handle->GetFeatureID())
-      {
-        if (find(m_handlesToDelete.begin(),
-                 m_handlesToDelete.end(), h) == m_handlesToDelete.end())
-          m_handlesToDelete.push_back(h);
-      }
-    });
-  }
-  else
-  {
-    if (find(m_handlesToDelete.begin(),
-             m_handlesToDelete.end(), handle) == m_handlesToDelete.end())
-      m_handlesToDelete.push_back(handle);
-  }
+  size_t const deletedCount = m_handlesCache.erase(GetHandleKey(handle));
+  ASSERT_NOT_EQUAL(deletedCount, 0, ());
+  if (deletedCount != 0)
+    Erase(handle);
+}
+
+uint64_t OverlayTree::GetHandleKey(ref_ptr<OverlayHandle> const & handle) const
+{
+  return reinterpret_cast<uint64_t>(handle.get());
 }
 
 void OverlayTree::Select(m2::PointD const & glbPoint, TOverlayContainer & result) const
@@ -327,11 +355,11 @@ void OverlayTree::Select(m2::PointD const & glbPoint, TOverlayContainer & result
   m2::RectD rect(pxPoint, pxPoint);
   rect.Inflate(kSearchRectHalfSize, kSearchRectHalfSize);
 
-  ForEach([&](ref_ptr<OverlayHandle> const & h)
+  for (auto it = m_handlesCache.begin(); it != m_handlesCache.end(); ++it)
   {
-    if (rect.IsPointInside(h->GetPivot(screen, false)))
-      result.push_back(h);
-  });
+    if (rect.IsPointInside(it->second->GetPivot(screen, false)))
+      result.push_back(it->second);
+  }
 }
 
 void OverlayTree::Select(m2::RectD const & rect, TOverlayContainer & result) const
diff --git a/drape/overlay_tree.hpp b/drape/overlay_tree.hpp
index d56ef3b43f..878bd1938b 100644
--- a/drape/overlay_tree.hpp
+++ b/drape/overlay_tree.hpp
@@ -9,6 +9,7 @@
 
 #include "std/array.hpp"
 #include "std/vector.hpp"
+#include "std/unordered_map.hpp"
 
 namespace dp
 {
@@ -39,12 +40,12 @@ class OverlayTree : public m4::Tree<ref_ptr<OverlayHandle>, detail::OverlayTrait
 public:
   OverlayTree();
 
-  bool Frame(bool is3d);
+  bool Frame();
   bool IsNeedUpdate() const;
-  void ForceUpdate();
 
   void StartOverlayPlacing(ScreenBase const & screen);
   void Add(ref_ptr<OverlayHandle> handle);
+  void Remove(ref_ptr<OverlayHandle> handle);
   void EndOverlayPlacing();
 
   void Select(m2::RectD const & rect, TOverlayContainer & result) const;
@@ -72,11 +73,16 @@ private:
                     ref_ptr<OverlayHandle> const & parentOverlay);
   bool CheckHandle(ref_ptr<OverlayHandle> handle, int currentRank,
                    ref_ptr<OverlayHandle> & parentOverlay) const;
-  void AddHandleToDelete(ref_ptr<OverlayHandle> const & handle);
+  void DeleteHandle(ref_ptr<OverlayHandle> const & handle);
+
+  uint64_t GetHandleKey(ref_ptr<OverlayHandle> const & handle) const;
 
   int m_frameCounter;
   array<vector<ref_ptr<OverlayHandle>>, dp::OverlayRanksCount> m_handles;
   vector<ref_ptr<OverlayHandle>> m_handlesToDelete;
+
+  unordered_map<uint64_t, ref_ptr<OverlayHandle>> m_handlesCache;
+
   bool m_followingMode;
 
 #ifdef COLLECT_DISPLACEMENT_INFO
diff --git a/drape/render_bucket.cpp b/drape/render_bucket.cpp
index 830b9dc0c5..fefe6f8029 100644
--- a/drape/render_bucket.cpp
+++ b/drape/render_bucket.cpp
@@ -71,7 +71,13 @@ void RenderBucket::CollectOverlayHandles(ref_ptr<OverlayTree> tree)
     tree->Add(make_ref(overlayHandle));
 }
 
-void RenderBucket::Render(ScreenBase const & screen)
+void RenderBucket::RemoveOverlayHandles(ref_ptr<OverlayTree> tree)
+{
+  for (drape_ptr<OverlayHandle> const & overlayHandle : m_overlay)
+    tree->Remove(make_ref(overlayHandle));
+}
+
+void RenderBucket::Render()
 {
   ASSERT(m_buffer != nullptr, ());
 
@@ -94,7 +100,7 @@ void RenderBucket::Render(ScreenBase const & screen)
       }
 
       if (handle->HasDynamicAttributes())
-        handle->GetAttributeMutation(rfpAttrib, screen);
+        handle->GetAttributeMutation(rfpAttrib);
     }
 
     m_buffer->ApplyMutation(hasIndexMutation ? rfpIndex : nullptr, rfpAttrib);
diff --git a/drape/render_bucket.hpp b/drape/render_bucket.hpp
index c66e51be72..c2837a96d1 100644
--- a/drape/render_bucket.hpp
+++ b/drape/render_bucket.hpp
@@ -36,7 +36,8 @@ public:
 
   void Update(ScreenBase const & modelView);
   void CollectOverlayHandles(ref_ptr<OverlayTree> tree);
-  void Render(ScreenBase const & screen);
+  void RemoveOverlayHandles(ref_ptr<OverlayTree> tree);
+  void Render();
 
   // Only for testing! Don't use this function in production code!
   void RenderDebug(ScreenBase const & screen) const;
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index 69f2de8797..b5f59541ff 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -58,7 +58,8 @@ struct MergedGroupKey
 };
 
 template <typename ToDo>
-bool RemoveGroups(ToDo & filter, vector<drape_ptr<RenderGroup>> & groups)
+bool RemoveGroups(ToDo & filter, vector<drape_ptr<RenderGroup>> & groups,
+                  ref_ptr<dp::OverlayTree> tree)
 {
   size_t startCount = groups.size();
   size_t count = startCount;
@@ -66,8 +67,9 @@ bool RemoveGroups(ToDo & filter, vector<drape_ptr<RenderGroup>> & groups)
   while (current < count)
   {
     drape_ptr<RenderGroup> & group = groups[current];
-    if (filter(move(group)))
+    if (filter(group))
     {
+      group->RemoveOverlay(tree);
       swap(group, groups.back());
       groups.pop_back();
       --count;
@@ -81,27 +83,6 @@ bool RemoveGroups(ToDo & filter, vector<drape_ptr<RenderGroup>> & groups)
   return startCount != count;
 }
 
-struct ActivateTilePredicate
-{
-  TileKey const & m_tileKey;
-
-  ActivateTilePredicate(TileKey const & tileKey)
-    : m_tileKey(tileKey)
-  {
-  }
-
-  bool operator()(drape_ptr<RenderGroup> & group) const
-  {
-    if (group->GetTileKey() == m_tileKey)
-    {
-      group->Appear();
-      return true;
-    }
-
-    return false;
-  }
-};
-
 struct RemoveTilePredicate
 {
   mutable bool m_deletionMark = false;
@@ -109,10 +90,9 @@ struct RemoveTilePredicate
 
   RemoveTilePredicate(function<bool(drape_ptr<RenderGroup> const &)> const & predicate)
     : m_predicate(predicate)
-  {
-  }
+  {}
 
-  bool operator()(drape_ptr<RenderGroup> && group) const
+  bool operator()(drape_ptr<RenderGroup> const & group) const
   {
     if (m_predicate(group))
     {
@@ -126,30 +106,6 @@ struct RemoveTilePredicate
   }
 };
 
-template <typename TPredicate>
-struct MoveTileFunctor
-{
-  TPredicate m_predicate;
-  vector<drape_ptr<RenderGroup>> & m_targetGroups;
-
-  MoveTileFunctor(TPredicate predicate, vector<drape_ptr<RenderGroup>> & groups)
-    : m_predicate(predicate)
-    , m_targetGroups(groups)
-  {
-  }
-
-  bool operator()(drape_ptr<RenderGroup> && group)
-  {
-    if (m_predicate(group))
-    {
-      m_targetGroups.push_back(move(group));
-      return true;
-    }
-
-    return false;
-  }
-};
-
 } // namespace
 
 FrontendRenderer::FrontendRenderer(Params const & params)
@@ -723,14 +679,14 @@ void FrontendRenderer::InvalidateRect(m2::RectD const & gRect)
   {
     ResolveTileKeys(rect, tiles);
 
-    auto eraseFunction = [&tiles](drape_ptr<RenderGroup> && group)
+    auto eraseFunction = [&tiles](drape_ptr<RenderGroup> const & group)
     {
       return tiles.count(group->GetTileKey()) == 0;
     };
 
     for (RenderLayer & layer : m_layers)
     {
-      RemoveGroups(eraseFunction, layer.m_renderGroups);
+      RemoveGroups(eraseFunction, layer.m_renderGroups, make_ref(m_overlayTree));
       layer.m_isDirty = true;
     }
 
@@ -783,12 +739,11 @@ void FrontendRenderer::AddToRenderGroup(dp::GLState const & state,
 void FrontendRenderer::RemoveRenderGroups(TRenderGroupRemovePredicate const & predicate)
 {
   ASSERT(predicate != nullptr, ());
-  m_overlayTree->ForceUpdate();
 
   for (RenderLayer & layer : m_layers)
   {
     RemoveTilePredicate f(predicate);
-    RemoveGroups(f, layer.m_renderGroups);
+    RemoveGroups(f, layer.m_renderGroups, make_ref(m_overlayTree));
     layer.m_isDirty |= f.m_deletionMark;
   }
 }
@@ -855,7 +810,7 @@ void FrontendRenderer::PrepareGpsTrackPoints(size_t pointsCount)
 
 void FrontendRenderer::BeginUpdateOverlayTree(ScreenBase const & modelView)
 {
-  if (m_overlayTree->Frame(modelView.isPerspective()))
+  if (m_overlayTree->Frame())
     m_overlayTree->StartOverlayPlacing(modelView);
 }
 
@@ -889,7 +844,7 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView)
   for (RenderLayer & layer : m_layers)
   {
     for (auto & group : layer.m_renderGroups)
-      layer.m_isDirty |= group->UpdateFeaturesWaitingStatus(isFeaturesWaiting);
+      layer.m_isDirty |= group->UpdateFeaturesWaitingStatus(isFeaturesWaiting, make_ref(m_overlayTree));
   }
 
   bool const isPerspective = modelView.isPerspective();
@@ -1002,7 +957,7 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView)
 void FrontendRenderer::Render2dLayer(ScreenBase const & modelView)
 {
   RenderLayer & layer2d = m_layers[RenderLayer::Geometry2dID];
-  layer2d.Sort();
+  layer2d.Sort(make_ref(m_overlayTree));
 
   for (drape_ptr<RenderGroup> const & group : layer2d.m_renderGroups)
     RenderSingleGroup(modelView, make_ref(group));
@@ -1012,7 +967,7 @@ void FrontendRenderer::Render3dLayer(ScreenBase const & modelView)
 {
   GLFunctions::glEnable(gl_const::GLDepthTest);
   RenderLayer & layer = m_layers[RenderLayer::Geometry3dID];
-  layer.Sort();
+  layer.Sort(make_ref(m_overlayTree));
   for (drape_ptr<RenderGroup> const & group : layer.m_renderGroups)
     RenderSingleGroup(modelView, make_ref(group));
 }
@@ -1020,7 +975,7 @@ void FrontendRenderer::Render3dLayer(ScreenBase const & modelView)
 void FrontendRenderer::RenderOverlayLayer(ScreenBase const & modelView)
 {
   RenderLayer & overlay = m_layers[RenderLayer::OverlayID];
-  overlay.Sort();
+  overlay.Sort(make_ref(m_overlayTree));
   BeginUpdateOverlayTree(modelView);
   for (drape_ptr<RenderGroup> & group : overlay.m_renderGroups)
     UpdateOverlayTree(modelView, group);
@@ -1545,9 +1500,7 @@ void FrontendRenderer::UpdateScene(ScreenBase const & modelView)
     return group->IsOverlay() && group->GetTileKey().m_zoomLevel > m_currentZoomLevel;
   };
   for (RenderLayer & layer : m_layers)
-    layer.m_isDirty |= RemoveGroups(removePredicate, layer.m_renderGroups);
-
-  m_overlayTree->ForceUpdate();
+    layer.m_isDirty |= RemoveGroups(removePredicate, layer.m_renderGroups, make_ref(m_overlayTree));
 
   if (m_lastReadModelView != modelView)
   {
@@ -1576,7 +1529,7 @@ FrontendRenderer::RenderLayer::RenderLayerID FrontendRenderer::RenderLayer::GetL
   return Geometry2dID;
 }
 
-void FrontendRenderer::RenderLayer::Sort()
+void FrontendRenderer::RenderLayer::Sort(ref_ptr<dp::OverlayTree> overlayTree)
 {
   if (!m_isDirty)
     return;
@@ -1587,6 +1540,7 @@ void FrontendRenderer::RenderLayer::Sort()
 
   while (!m_renderGroups.empty() && m_renderGroups.back()->CanBeDeleted())
   {
+    m_renderGroups.back()->RemoveOverlay(overlayTree);
     m_renderGroups.pop_back();
   }
 }
diff --git a/drape_frontend/frontend_renderer.hpp b/drape_frontend/frontend_renderer.hpp
index 09fa8f7a1a..899ccab2cc 100755
--- a/drape_frontend/frontend_renderer.hpp
+++ b/drape_frontend/frontend_renderer.hpp
@@ -241,7 +241,7 @@ private:
     vector<drape_ptr<RenderGroup>> m_renderGroups;
     bool m_isDirty = false;
 
-    inline void Sort();
+    void Sort(ref_ptr<dp::OverlayTree> overlayTree);
   };
 
   array<RenderLayer, RenderLayer::LayerCountID> m_layers;
diff --git a/drape_frontend/gps_track_renderer.cpp b/drape_frontend/gps_track_renderer.cpp
index 250b01bb46..d3c82e404e 100644
--- a/drape_frontend/gps_track_renderer.cpp
+++ b/drape_frontend/gps_track_renderer.cpp
@@ -296,7 +296,7 @@ void GpsTrackRenderer::RenderTrack(ScreenBase const & screen, int zoomLevel,
 
   for (size_t i = 0; i < m_renderData.size(); i++)
     if (m_handlesCache[i].second != 0)
-      m_renderData[i]->m_bucket->Render(screen);
+      m_renderData[i]->m_bucket->Render();
 }
 
 void GpsTrackRenderer::Update()
diff --git a/drape_frontend/gps_track_shape.cpp b/drape_frontend/gps_track_shape.cpp
index 662d5ec2dd..dff3bd9442 100644
--- a/drape_frontend/gps_track_shape.cpp
+++ b/drape_frontend/gps_track_shape.cpp
@@ -68,11 +68,8 @@ GpsTrackHandle::GpsTrackHandle(size_t pointsCount)
   m_buffer.resize(pointsCount * dp::Batcher::VertexPerQuad);
 }
 
-void GpsTrackHandle::GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator,
-                                          ScreenBase const & screen) const
+void GpsTrackHandle::GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator) const
 {
-  UNUSED_VALUE(screen);
-
   if (!m_needUpdate)
     return;
 
diff --git a/drape_frontend/gps_track_shape.hpp b/drape_frontend/gps_track_shape.hpp
index 8b22483bc2..21c67f3798 100644
--- a/drape_frontend/gps_track_shape.hpp
+++ b/drape_frontend/gps_track_shape.hpp
@@ -49,8 +49,7 @@ class GpsTrackHandle : public dp::OverlayHandle
 
 public:
   GpsTrackHandle(size_t pointsCount);
-  void GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator,
-                            ScreenBase const & screen) const override;
+  void GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator) const override;
   bool Update(ScreenBase const & screen) override;
   m2::RectD GetPixelRect(ScreenBase const & screen, bool perspective) const override;
   void GetPixelShape(ScreenBase const & screen, Rects & rects, bool perspective) const override;
diff --git a/drape_frontend/gui/gui_text.cpp b/drape_frontend/gui/gui_text.cpp
index c876b0b14b..c00408e332 100644
--- a/drape_frontend/gui/gui_text.cpp
+++ b/drape_frontend/gui/gui_text.cpp
@@ -455,11 +455,8 @@ MutableLabelHandle::MutableLabelHandle(uint32_t id, dp::Anchor anchor, m2::Point
   , m_glyphsReady(false)
 {}
 
-void MutableLabelHandle::GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator,
-                                              ScreenBase const & screen) const
+void MutableLabelHandle::GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator) const
 {
-  UNUSED_VALUE(screen);
-
   if (!m_isContentDirty)
     return;
 
diff --git a/drape_frontend/gui/gui_text.hpp b/drape_frontend/gui/gui_text.hpp
index 92fc5318d3..8da28f40b9 100644
--- a/drape_frontend/gui/gui_text.hpp
+++ b/drape_frontend/gui/gui_text.hpp
@@ -150,8 +150,7 @@ public:
   MutableLabelHandle(uint32_t id, dp::Anchor anchor, m2::PointF const & pivot,
                      ref_ptr<dp::TextureManager> textures);
 
-  void GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator,
-                            ScreenBase const & screen) const override;
+  void GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator) const override;
 
   bool Update(ScreenBase const & screen) override;
 
diff --git a/drape_frontend/gui/shape.cpp b/drape_frontend/gui/shape.cpp
index 610bf4c73c..a385905494 100644
--- a/drape_frontend/gui/shape.cpp
+++ b/drape_frontend/gui/shape.cpp
@@ -116,7 +116,7 @@ void ShapeRenderer::Render(ScreenBase const & screen, ref_ptr<dp::GpuProgramMana
         {
           dp::AttributeBufferMutator mutator;
           ref_ptr<dp::AttributeBufferMutator> mutatorRef = make_ref(&mutator);
-          info.m_handle->GetAttributeMutation(mutatorRef, screen);
+          info.m_handle->GetAttributeMutation(mutatorRef);
           info.m_buffer->ApplyMutation(nullptr, mutatorRef);
         }
 
diff --git a/drape_frontend/path_text_shape.cpp b/drape_frontend/path_text_shape.cpp
index 0a23de4e52..83714d9f1f 100644
--- a/drape_frontend/path_text_shape.cpp
+++ b/drape_frontend/path_text_shape.cpp
@@ -162,12 +162,11 @@ public:
     }
   }
 
-  void GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator,
-                            ScreenBase const & screen) const override
+  void GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator) const override
   {
     // for visible text paths we always update normals
     SetForceUpdateNormals(IsVisible());
-    TextHandle::GetAttributeMutation(mutator, screen);
+    TextHandle::GetAttributeMutation(mutator);
   }
 
   uint64_t GetPriorityMask() const override
diff --git a/drape_frontend/render_group.cpp b/drape_frontend/render_group.cpp
index d1ddf7e9bd..b325bbb1a8 100755
--- a/drape_frontend/render_group.cpp
+++ b/drape_frontend/render_group.cpp
@@ -74,6 +74,12 @@ void RenderGroup::CollectOverlay(ref_ptr<dp::OverlayTree> tree)
     renderBucket->CollectOverlayHandles(tree);
 }
 
+void RenderGroup::RemoveOverlay(ref_ptr<dp::OverlayTree> tree)
+{
+  for (auto & renderBucket : m_renderBuckets)
+    renderBucket->RemoveOverlayHandles(tree);
+}
+
 void RenderGroup::Render(ScreenBase const & screen)
 {
   BaseRenderGroup::Render(screen);
@@ -93,13 +99,13 @@ void RenderGroup::Render(ScreenBase const & screen)
     dp::ApplyUniforms(m_uniforms, shader);
 
     for(auto & renderBucket : m_renderBuckets)
-      renderBucket->Render(screen);
+      renderBucket->Render();
 
     m_uniforms.SetFloatValue("u_contrastGamma", params.m_contrast, params.m_gamma);
     m_uniforms.SetFloatValue("u_isOutlinePass", 0.0f);
     dp::ApplyUniforms(m_uniforms, shader);
     for(auto & renderBucket : m_renderBuckets)
-      renderBucket->Render(screen);
+      renderBucket->Render();
   }
   else if (programIndex == gpu::TEXT_PROGRAM ||
            program3dIndex == gpu::TEXT_BILLBOARD_PROGRAM)
@@ -107,14 +113,14 @@ void RenderGroup::Render(ScreenBase const & screen)
     m_uniforms.SetFloatValue("u_contrastGamma", params.m_contrast, params.m_gamma);
     dp::ApplyUniforms(m_uniforms, shader);
     for(auto & renderBucket : m_renderBuckets)
-      renderBucket->Render(screen);
+      renderBucket->Render();
   }
   else
   {
     dp::ApplyUniforms(m_uniforms, shader);
 
     for(drape_ptr<dp::RenderBucket> & renderBucket : m_renderBuckets)
-      renderBucket->Render(screen);
+      renderBucket->Render();
   }
 
 #ifdef RENDER_DEBUG_RECTS
@@ -181,7 +187,7 @@ void RenderGroup::Disappear()
   //}
 }
 
-bool RenderGroup::UpdateFeaturesWaitingStatus(TCheckFeaturesWaiting isFeaturesWaiting)
+bool RenderGroup::UpdateFeaturesWaitingStatus(TCheckFeaturesWaiting isFeaturesWaiting, ref_ptr<dp::OverlayTree> tree)
 {
   if (!m_sharedFeaturesWaiting)
     return false;
@@ -195,6 +201,7 @@ bool RenderGroup::UpdateFeaturesWaitingStatus(TCheckFeaturesWaiting isFeaturesWa
                                                         : isTileVisible;
     if (!visibleBucket)
     {
+      m_renderBuckets[i]->RemoveOverlayHandles(tree);
       swap(m_renderBuckets[i], m_renderBuckets.back());
       m_renderBuckets.pop_back();
     }
@@ -268,7 +275,7 @@ void UserMarkRenderGroup::Render(ScreenBase const & screen)
   if (m_renderBucket != nullptr)
   {
     m_renderBucket->GetBuffer()->Build(shader);
-    m_renderBucket->Render(screen);
+    m_renderBucket->Render();
   }
 }
 
diff --git a/drape_frontend/render_group.hpp b/drape_frontend/render_group.hpp
index d873c6d866..4941defe54 100755
--- a/drape_frontend/render_group.hpp
+++ b/drape_frontend/render_group.hpp
@@ -57,6 +57,7 @@ public:
 
   void Update(ScreenBase const & modelView);
   void CollectOverlay(ref_ptr<dp::OverlayTree> tree);
+  void RemoveOverlay(ref_ptr<dp::OverlayTree> tree);
   void Render(ScreenBase const & screen) override;
 
   void AddBucket(drape_ptr<dp::RenderBucket> && bucket);
@@ -78,7 +79,7 @@ public:
   }
 
   using TCheckFeaturesWaiting = function<bool(m2::RectD const &)>;
-  bool UpdateFeaturesWaitingStatus(TCheckFeaturesWaiting isFeaturesWaiting);
+  bool UpdateFeaturesWaitingStatus(TCheckFeaturesWaiting isFeaturesWaiting, ref_ptr<dp::OverlayTree> tree);
 
   bool IsLess(RenderGroup const & other) const;
 
diff --git a/drape_frontend/route_renderer.cpp b/drape_frontend/route_renderer.cpp
index eadb63ff81..9336876dac 100644
--- a/drape_frontend/route_renderer.cpp
+++ b/drape_frontend/route_renderer.cpp
@@ -193,7 +193,7 @@ void RouteRenderer::RenderRoute(ScreenBase const & screen, ref_ptr<dp::GpuProgra
 
     // render routes
     for (drape_ptr<dp::RenderBucket> const & bucket : m_routeData->m_route.m_buckets)
-      bucket->Render(screen);
+      bucket->Render();
   }
 
   // render arrows
@@ -253,7 +253,7 @@ void RouteRenderer::RenderRouteSign(drape_ptr<RouteSignData> const & sign, Scree
   for (auto const & bucket : sign->m_sign.m_buckets)
   {
     bucket->GetBuffer()->Build(program);
-    bucket->Render(screen);
+    bucket->Render();
   }
 }
 
@@ -292,7 +292,7 @@ void RouteRenderer::RenderArrow(ref_ptr<dp::GpuProgram> prg, drape_ptr<ArrowRend
 
       dp::ApplyUniforms(uniformStorage, prg);
       for (drape_ptr<dp::RenderBucket> const & bucket : property->m_arrow.m_buckets)
-        bucket->Render(screen);
+        bucket->Render();
     }
   }
 }
diff --git a/drape_frontend/text_handle.cpp b/drape_frontend/text_handle.cpp
index 609190153e..0c07012f7b 100644
--- a/drape_frontend/text_handle.cpp
+++ b/drape_frontend/text_handle.cpp
@@ -33,11 +33,8 @@ TextHandle::TextHandle(FeatureID const & id, strings::UniString const & text,
   , m_glyphsReady(false)
 {}
 
-void TextHandle::GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator,
-                                      ScreenBase const & screen) const
+void TextHandle::GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator) const
 {
-  UNUSED_VALUE(screen);
-
   bool const isVisible = IsVisible();
   if (!m_forceUpdateNormals && m_isLastVisible == isVisible)
     return;
diff --git a/drape_frontend/text_handle.hpp b/drape_frontend/text_handle.hpp
index 5bbbf023e6..4ec3e993c5 100644
--- a/drape_frontend/text_handle.hpp
+++ b/drape_frontend/text_handle.hpp
@@ -30,8 +30,7 @@ public:
 
   bool Update(ScreenBase const & screen) override;
 
-  void GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator,
-                            ScreenBase const & screen) const override;
+  void GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator) const override;
 
   bool IndexesRequired() const override;
 
diff --git a/drape_head/testing_engine.cpp b/drape_head/testing_engine.cpp
index d4cbdebbac..d2fa9491c3 100644
--- a/drape_head/testing_engine.cpp
+++ b/drape_head/testing_engine.cpp
@@ -398,7 +398,7 @@ void TestingEngine::Draw()
     for (size_t i = 0; i < buckets.size(); ++i)
       buckets[i]->CollectOverlayHandles(make_ref(&tree));
     for (size_t i = 0; i < buckets.size(); ++i)
-      buckets[i]->Render(m_modelView);
+      buckets[i]->Render();
     tree.EndOverlayPlacing();
   }
 }