User mark layer.

14 files changed, 180 insertions, 203 deletions

diff --git a/drape_frontend/CMakeLists.txt b/drape_frontend/CMakeLists.txt
index ce27fa4bbd..e77da81ef8 100644
--- a/drape_frontend/CMakeLists.txt
+++ b/drape_frontend/CMakeLists.txt
@@ -204,6 +204,8 @@ set(
   traffic_renderer.hpp
   user_event_stream.cpp
   user_event_stream.hpp
+  user_mark_generator.cpp
+  user_mark_generator.hpp
   user_mark_shapes.cpp
   user_mark_shapes.hpp
   user_marks_provider.cpp
diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp
index 68abfcba2c..b45b1f7cde 100644
--- a/drape_frontend/backend_renderer.cpp
+++ b/drape_frontend/backend_renderer.cpp
@@ -250,6 +250,16 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
       break;
     }
 
+  case Message::ChangeUserMarkLayerVisibility:
+    {
+      ref_ptr<ChangeUserMarkLayerVisibilityMessage> msg = message;
+      m_userMarkGenerator->SetGroupVisibility(static_cast<GroupID>(msg->GetLayerId()), msg->IsVisible());
+      m_commutator->PostMessage(ThreadsCommutator::RenderThread,
+                                make_unique_dp<InvalidateUserMarksMessage>(msg->GetLayerId()),
+                                MessagePriority::Normal);
+      break;
+    }
+
   case Message::UpdateUserMarkLayer:
     {
       ref_ptr<UpdateUserMarkLayerMessage> msg = message;
@@ -261,6 +271,17 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
       break;
     }
 
+  case Message::ClearUserMarkLayer:
+    {
+      ref_ptr<ClearUserMarkLayerMessage> msg = message;
+      size_t const layerId = msg->GetLayerId();
+      m_userMarkGenerator->ClearUserMarks(static_cast<GroupID>(layerId));
+      m_commutator->PostMessage(ThreadsCommutator::RenderThread,
+                                make_unique_dp<InvalidateUserMarksMessage>(layerId),
+                                MessagePriority::Normal);
+      break;
+    }
+
   case Message::AddSubroute:
     {
       ref_ptr<AddSubrouteMessage> msg = message;
diff --git a/drape_frontend/drape_engine.cpp b/drape_frontend/drape_engine.cpp
index 15a53e8751..d4a3b0bf57 100644
--- a/drape_frontend/drape_engine.cpp
+++ b/drape_frontend/drape_engine.cpp
@@ -195,14 +195,14 @@ void DrapeEngine::SetModelViewAnyRect(m2::AnyRectD const & rect, bool isAnim)
 
 void DrapeEngine::ClearUserMarksLayer(size_t layerId)
 {
-  m_threadCommutator->PostMessage(ThreadsCommutator::RenderThread,
+  m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
                                   make_unique_dp<ClearUserMarkLayerMessage>(layerId),
                                   MessagePriority::Normal);
 }
 
 void DrapeEngine::ChangeVisibilityUserMarksLayer(size_t layerId, bool isVisible)
 {
-  m_threadCommutator->PostMessage(ThreadsCommutator::RenderThread,
+  m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
                                   make_unique_dp<ChangeUserMarkLayerVisibilityMessage>(layerId, isVisible),
                                   MessagePriority::Normal);
 }
diff --git a/drape_frontend/drape_frontend.pro b/drape_frontend/drape_frontend.pro
index 634500eedc..9a43575674 100755
--- a/drape_frontend/drape_frontend.pro
+++ b/drape_frontend/drape_frontend.pro
@@ -100,6 +100,7 @@ SOURCES += \
     traffic_generator.cpp \
     traffic_renderer.cpp \
     user_event_stream.cpp \
+    user_mark_generator.cpp \
     user_mark_shapes.cpp \
     user_marks_provider.cpp \
     visual_params.cpp \
@@ -114,7 +115,6 @@ SOURCES += \
     watch/geometry_processors.cpp \
     watch/feature_processor.cpp \
     watch/default_font.cpp \
-    user_mark_generator.cpp
 
 HEADERS += \
     animation/animation.hpp \
@@ -213,6 +213,7 @@ HEADERS += \
     traffic_generator.hpp \
     traffic_renderer.hpp \
     user_event_stream.hpp \
+    user_mark_generator.hpp \
     user_mark_shapes.hpp \
     user_marks_provider.hpp \
     visual_params.hpp \
@@ -236,7 +237,6 @@ HEADERS += \
     watch/brush_info.hpp \
     watch/geometry_processors.hpp \
     watch/feature_processor.hpp \
-    user_mark_generator.hpp
 
 OTHER_FILES += \
     shaders/area.vsh.glsl \
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index 3cfadf5b05..67f7c661dc 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -228,7 +228,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
       if (key.m_zoomLevel == m_currentZoomLevel && CheckTileGenerations(key))
       {
         PrepareBucket(state, bucket);
-        AddToRenderGroup(state, std::move(bucket), key);
+        AddToRenderGroup<RenderGroup>(state, std::move(bucket), key);
       }
       break;
     }
@@ -243,8 +243,8 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
             CheckTileGenerations(overlayRenderData.m_tileKey))
         {
           PrepareBucket(overlayRenderData.m_state, overlayRenderData.m_bucket);
-          AddToRenderGroup(overlayRenderData.m_state, std::move(overlayRenderData.m_bucket),
-                           overlayRenderData.m_tileKey);
+          AddToRenderGroup<RenderGroup>(overlayRenderData.m_state, std::move(overlayRenderData.m_bucket),
+                                        overlayRenderData.m_tileKey);
         }
       }
       UpdateCanBeDeletedStatus();
@@ -297,47 +297,20 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
   case Message::FlushUserMarks:
     {
       ref_ptr<FlushUserMarksMessage> msg = message;
-      size_t const layerId = msg->GetLayerId();
       TUserMarksRenderData marksRenderData = msg->AcceptRenderData();
-      for (UserMarkRenderData & renderData : marksRenderData)
+      for (auto & renderData : marksRenderData)
       {
-        PrepareBucket(renderData.m_state, renderData.m_bucket);
-        auto program = m_gpuProgramManager->GetProgram(renderData.m_state.GetProgramIndex());
-        auto program3d = m_gpuProgramManager->GetProgram(renderData.m_state.GetProgram3dIndex());
-        auto group = make_unique_dp<UserMarkRenderGroup>(layerId, renderData.m_state, renderData.m_tileKey,
-                                                         std::move(renderData.m_bucket));
-        m_userMarkRenderGroups.push_back(std::move(group));
-        m_userMarkRenderGroups.back()->SetRenderParams(program, program3d, make_ref(&m_generalUniforms));
+        if (renderData.m_tileKey.m_zoomLevel == m_currentZoomLevel &&
+            CheckTileGenerations(renderData.m_tileKey))
+        {
+          PrepareBucket(renderData.m_state, renderData.m_bucket);
+          AddToRenderGroup<UserMarkRenderGroup>(renderData.m_state, std::move(renderData.m_bucket),
+                                                renderData.m_tileKey);
+        }
       }
       break;
     }
 
-  case Message::ClearUserMarkLayer:
-    {
-      ref_ptr<ClearUserMarkLayerMessage> msg = message;
-      size_t const layerId = msg->GetLayerId();
-      auto const functor = [&layerId](drape_ptr<UserMarkRenderGroup> const & g)
-      {
-        return g->GetLayerId() == layerId;
-      };
-
-      auto const iter = std::remove_if(m_userMarkRenderGroups.begin(),
-                                       m_userMarkRenderGroups.end(),
-                                       functor);
-      m_userMarkRenderGroups.erase(iter, m_userMarkRenderGroups.end());
-      break;
-    }
-
-  case Message::ChangeUserMarkLayerVisibility:
-    {
-      ref_ptr<ChangeUserMarkLayerVisibilityMessage> msg = message;
-      if (msg->IsVisible())
-        m_userMarkVisibility.insert(msg->GetLayerId());
-      else
-        m_userMarkVisibility.erase(msg->GetLayerId());
-      break;
-    }
-
   case Message::GuiLayerRecached:
     {
       ref_ptr<GuiLayerRecachedMessage> msg = message;
@@ -774,6 +747,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
   case Message::SetSimplifiedTrafficColors:
   case Message::SetDisplacementMode:
   case Message::UpdateMetalines:
+  case Message::InvalidateUserMarks:
     {
       m_forceUpdateScene = true;
       break;
@@ -978,6 +952,7 @@ void FrontendRenderer::OnResize(ScreenBase const & screen)
   RefreshPivotTransform(screen);
 }
 
+template<typename TRenderGroup>
 void FrontendRenderer::AddToRenderGroup(dp::GLState const & state,
                                         drape_ptr<dp::RenderBucket> && renderBucket,
                                         TileKey const & newTile)
@@ -995,7 +970,7 @@ void FrontendRenderer::AddToRenderGroup(dp::GLState const & state,
     }
   }
 
-  drape_ptr<RenderGroup> group = make_unique_dp<RenderGroup>(state, newTile);
+  drape_ptr<TRenderGroup> group = make_unique_dp<TRenderGroup>(state, newTile);
   ref_ptr<dp::GpuProgram> program = m_gpuProgramManager->GetProgram(state.GetProgramIndex());
   ref_ptr<dp::GpuProgram> program3d = m_gpuProgramManager->GetProgram(state.GetProgram3dIndex());
   group->SetRenderParams(program, program3d, make_ref(&m_generalUniforms));
@@ -1297,17 +1272,12 @@ void FrontendRenderer::RenderTrafficAndRouteLayer(ScreenBase const & modelView)
 
 void FrontendRenderer::RenderUserMarksLayer(ScreenBase const & modelView)
 {
-  double const kExtension = 1.1;
-  m2::RectD screenRect = modelView.ClipRect();
-  screenRect.Scale(kExtension);
-  for (auto const & group : m_userMarkRenderGroups)
+  RenderLayer & userMarks = m_layers[RenderLayer::UserMarkID];
+  for (drape_ptr<RenderGroup> & group : userMarks.m_renderGroups)
   {
-    ASSERT(group.get() != nullptr, ());
-    //if (m_userMarkVisibility.find(group->GetLayerId()) != m_userMarkVisibility.end())
-    {
-      if (!group->CanBeClipped() || screenRect.IsIntersect(group->GetTileKey().GetGlobalRect()))
-        RenderSingleGroup(modelView, make_ref(group));
-    }
+    // TODO: Remove after user lines complete realization.
+    //if (!group->CanBeClipped())
+      RenderSingleGroup(modelView, make_ref(group));
   }
 }
 
@@ -1711,7 +1681,6 @@ void FrontendRenderer::OnContextDestroy()
   m_overlayTree->SetSelectedFeature(FeatureID());
   m_overlayTree->Clear();
 
-  m_userMarkRenderGroups.clear();
   m_guiRenderer.reset();
   m_selectionShape.reset();
   m_buildingsFramebuffer.reset();
@@ -1897,7 +1866,6 @@ void FrontendRenderer::ReleaseResources()
   for (RenderLayer & layer : m_layers)
     layer.m_renderGroups.clear();
 
-  m_userMarkRenderGroups.clear();
   m_guiRenderer.reset();
   m_myPositionController.reset();
   m_selectionShape.release();
@@ -2048,6 +2016,9 @@ FrontendRenderer::RenderLayer::RenderLayerID FrontendRenderer::RenderLayer::GetL
   if (state.GetDepthLayer() == dp::GLState::OverlayLayer)
     return OverlayID;
 
+  if (state.GetDepthLayer() == dp::GLState::UserMarkLayer)
+    return UserMarkID;
+
   if (state.GetProgram3dIndex() == gpu::AREA_3D_PROGRAM ||
       state.GetProgram3dIndex() == gpu::AREA_3D_OUTLINE_PROGRAM)
     return Geometry3dID;
diff --git a/drape_frontend/frontend_renderer.hpp b/drape_frontend/frontend_renderer.hpp
index 7412b1edbd..0483e89a00 100755
--- a/drape_frontend/frontend_renderer.hpp
+++ b/drape_frontend/frontend_renderer.hpp
@@ -202,6 +202,7 @@ private:
   void UpdateOverlayTree(ScreenBase const & modelView, drape_ptr<RenderGroup> & renderGroup);
   void EndUpdateOverlayTree();
 
+  template<typename TRenderGroup>
   void AddToRenderGroup(dp::GLState const & state, drape_ptr<dp::RenderBucket> && renderBucket,
                         TileKey const & newTile);
 
@@ -239,6 +240,7 @@ private:
       Geometry2dID,
       OverlayID,
       Geometry3dID,
+      UserMarkID,
       LayerCountID
     };
 
@@ -251,8 +253,6 @@ private:
   };
 
   std::array<RenderLayer, RenderLayer::LayerCountID> m_layers;
-  std::vector<drape_ptr<UserMarkRenderGroup>> m_userMarkRenderGroups;
-  std::unordered_set<size_t> m_userMarkVisibility;
 
   drape_ptr<gui::LayerRenderer> m_guiRenderer;
   drape_ptr<MyPositionController> m_myPositionController;
diff --git a/drape_frontend/message_subclasses.hpp b/drape_frontend/message_subclasses.hpp
index 312b63584e..bc39ac6724 100644
--- a/drape_frontend/message_subclasses.hpp
+++ b/drape_frontend/message_subclasses.hpp
@@ -16,7 +16,6 @@
 #include "drape_frontend/selection_shape.hpp"
 #include "drape_frontend/tile_utils.hpp"
 #include "drape_frontend/traffic_generator.hpp"
-#include "drape_frontend/user_mark_generator.hpp"
 #include "drape_frontend/user_mark_shapes.hpp"
 #include "drape_frontend/user_marks_provider.hpp"
 
@@ -243,9 +242,6 @@ public:
     , m_renderParams(std::move(renderParams))
   {}
 
-  ~UpdateUserMarkLayerMessage() override
-  {}
-
   Type GetType() const override { return Message::UpdateUserMarkLayer; }
 
   drape_ptr<UserMarksRenderCollection> && AcceptRenderParams() { return std::move(m_renderParams); }
@@ -259,7 +255,7 @@ class FlushUserMarksMessage : public BaseUserMarkLayerMessage
 public:
   FlushUserMarksMessage(size_t layerId, TUserMarksRenderData && renderData)
     : BaseUserMarkLayerMessage(layerId)
-    , m_renderData(move(renderData))
+    , m_renderData(std::move(renderData))
   {}
 
   Type GetType() const override { return Message::FlushUserMarks; }
diff --git a/drape_frontend/render_group.cpp b/drape_frontend/render_group.cpp
index 999428ae1a..be6a47c370 100755
--- a/drape_frontend/render_group.cpp
+++ b/drape_frontend/render_group.cpp
@@ -200,12 +200,9 @@ bool RenderGroupComparator::operator()(drape_ptr<RenderGroup> const & l, drape_p
   return false;
 }
 
-UserMarkRenderGroup::UserMarkRenderGroup(size_t layerId, dp::GLState const & state, TileKey const & tileKey,
-                                         drape_ptr<dp::RenderBucket> && bucket)
+UserMarkRenderGroup::UserMarkRenderGroup(dp::GLState const & state, TileKey const & tileKey)
   : TBase(state, tileKey)
-  , m_renderBucket(move(bucket))
   , m_animation(new OpacityAnimation(0.25 /*duration*/, 0.0 /* minValue */, 1.0 /* maxValue*/))
-  , m_layerId(layerId)
 {
   m_mapping.AddRangePoint(0.6, 1.3);
   m_mapping.AddRangePoint(0.85, 0.8);
@@ -226,30 +223,6 @@ void UserMarkRenderGroup::UpdateAnimation()
   m_uniforms.SetFloatValue("u_interpolationT", m_mapping.GetValue(t));
 }
 
-void UserMarkRenderGroup::Render(ScreenBase const & screen)
-{
-  BaseRenderGroup::Render(screen);
-
-  // Set tile-based model-view matrix.
-  {
-    math::Matrix<float, 4, 4> mv = GetTileKey().GetTileBasedModelView(screen);
-    m_uniforms.SetMatrix4x4Value("modelView", mv.m_data);
-  }
-
-  ref_ptr<dp::GpuProgram> shader = screen.isPerspective() ? m_shader3d : m_shader;
-  dp::ApplyUniforms(m_uniforms, shader);
-  if (m_renderBucket != nullptr)
-  {
-    m_renderBucket->GetBuffer()->Build(shader);
-    m_renderBucket->Render(m_state.GetDrawAsLine());
-  }
-}
-
-size_t UserMarkRenderGroup::GetLayerId() const
-{
-  return m_layerId;
-}
-
 bool UserMarkRenderGroup::CanBeClipped() const
 {
   return m_state.GetProgramIndex() != gpu::LINE_PROGRAM;
diff --git a/drape_frontend/render_group.hpp b/drape_frontend/render_group.hpp
index 8c99d1b86f..4bf8122399 100755
--- a/drape_frontend/render_group.hpp
+++ b/drape_frontend/render_group.hpp
@@ -91,27 +91,21 @@ public:
   bool m_pendingOnDeleteFound = false;
 };
 
-class UserMarkRenderGroup : public BaseRenderGroup
+class UserMarkRenderGroup : public RenderGroup
 {
-  using TBase = BaseRenderGroup;
+  using TBase = RenderGroup;
 
 public:
-  UserMarkRenderGroup(size_t layerId, dp::GLState const & state, TileKey const & tileKey,
-                      drape_ptr<dp::RenderBucket> && bucket);
+  UserMarkRenderGroup(dp::GLState const & state, TileKey const & tileKey);
   ~UserMarkRenderGroup() override;
 
   void UpdateAnimation() override;
-  void Render(ScreenBase const & screen) override;
-
-  size_t GetLayerId() const;
 
   bool CanBeClipped() const;
 
 private:
-  drape_ptr<dp::RenderBucket> m_renderBucket;
   unique_ptr<OpacityAnimation> m_animation;
   ValueMapping<float> m_mapping;
-  size_t m_layerId;
 };
 
 } // namespace df
diff --git a/drape_frontend/user_mark_generator.cpp b/drape_frontend/user_mark_generator.cpp
index ce7e75ea67..561d942638 100644
--- a/drape_frontend/user_mark_generator.cpp
+++ b/drape_frontend/user_mark_generator.cpp
@@ -1,26 +1,34 @@
 #include "drape_frontend/user_mark_generator.hpp"
-#include "drape_frontend/map_shape.hpp"
-#include "drape_frontend/shader_def.hpp"
-#include "drape_frontend/shape_view_params.hpp"
+#include "drape_frontend/tile_utils.hpp"
 
-#include "drape/utils/vertex_decl.hpp"
+#include "indexer/scales.hpp"
 
 namespace df
 {
 UserMarkGenerator::UserMarkGenerator(TFlushFn const & flushFn)
   : m_flushFn(flushFn)
 {
+  ASSERT(m_flushFn != nullptr, ());
+}
+
+void UserMarkGenerator::ClearUserMarks(GroupID groupId)
+{
+  m_groupsVisibility.erase(groupId);
+  m_marks.erase(groupId);
+  m_lines.erase(groupId);
+  UpdateMarksIndex(groupId);
+  UpdateLinesIndex(groupId);
 }
 
 void UserMarkGenerator::SetUserMarks(uint32_t groupId, drape_ptr<UserMarksRenderCollection> && marks)
 {
-  m_marks.insert(make_pair(groupId, std::move(marks)));
+  m_marks.insert(std::make_pair(groupId, std::move(marks)));
   UpdateMarksIndex(groupId);
 }
 
 void UserMarkGenerator::SetUserLines(uint32_t groupId, drape_ptr<UserLinesRenderCollection> && lines)
 {
-  m_lines.insert(make_pair(groupId, std::move(lines)));
+  m_lines.insert(std::make_pair(groupId, std::move(lines)));
   UpdateLinesIndex(groupId);
 }
 
@@ -30,11 +38,12 @@ void UserMarkGenerator::UpdateMarksIndex(uint32_t groupId)
   {
     auto itGroupIndexes = tileGroups.second->find(groupId);
     if (itGroupIndexes != tileGroups.second->end())
-    {
       itGroupIndexes->second->m_markIndexes.clear();
-    }
   }
 
+  if (m_marks.find(groupId) == m_marks.end())
+    return;
+
   UserMarksRenderCollection & marks = *m_marks[groupId];
   for (size_t markIndex = 0; markIndex < marks.size(); ++markIndex)
   {
@@ -55,17 +64,18 @@ void UserMarkGenerator::UpdateLinesIndex(uint32_t groupId)
   {
     auto itGroupIndexes = tileGroups.second->find(groupId);
     if (itGroupIndexes != tileGroups.second->end())
-    {
       itGroupIndexes->second->m_lineIndexes.clear();
-    }
   }
 
+  if (m_lines.find(groupId) == m_lines.end())
+    return;
+
   UserLinesRenderCollection & lines = *m_lines[groupId];
   for (size_t lineIndex = 0; lineIndex < lines.size(); ++lineIndex)
   {
     for (int zoomLevel = 1; zoomLevel <= scales::GetUpperScale(); ++zoomLevel)
     {
-      // TODO: Calculate tiles for the line.
+      // TODO: Calculate tiles for the line properly.
       std::set<TileKey> tiles;
       for (size_t i = 0, sz = lines[lineIndex].m_points.size(); i < sz; ++i)
       {
@@ -122,11 +132,25 @@ void UserMarkGenerator::CleanIndex()
     else
       ++tileIt;
   }
+
+  for (auto & tileGroups : m_marksIndex)
+  {
+    for (auto groupIt = tileGroups.second->begin(); groupIt != tileGroups.second->end();)
+    {
+      if (groupIt->second->m_markIndexes.empty() && groupIt->second->m_lineIndexes.empty())
+        groupIt = tileGroups.second->erase(groupIt);
+      else
+        ++groupIt;
+    }
+  }
 }
 
 void UserMarkGenerator::SetGroupVisibility(GroupID groupId, bool isVisible)
 {
-  m_groupsVisibility[groupId] = isVisible;
+  if (isVisible)
+    m_groupsVisibility.insert(groupId);
+  else
+    m_groupsVisibility.erase(groupId);
 }
 
 void UserMarkGenerator::GenerateUserMarksGeometry(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures)
@@ -142,15 +166,13 @@ void UserMarkGenerator::GenerateUserMarksGeometry(TileKey const & tileKey, ref_p
     UserMarksRenderCollection const & renderParams = *m_marks[groupId];
     MarkIndexesCollection const & indexes = groupPair.second->m_markIndexes;
 
-    //if (!m_groupsVisibility[groupId])
-    //  continue;
+    if (m_groupsVisibility.find(groupId) == m_groupsVisibility.end())
+      continue;
 
     TUserMarksRenderData renderData;
-    UserMarkShape::Draw(tileKey, textures, renderParams, indexes, renderData);
+    CacheUserMarks(tileKey, textures, renderParams, indexes, renderData);
 
     m_flushFn(groupId, std::move(renderData));
   }
 }
-
-
 }  // namespace df
diff --git a/drape_frontend/user_mark_generator.hpp b/drape_frontend/user_mark_generator.hpp
index 342c497858..8295e01f51 100644
--- a/drape_frontend/user_mark_generator.hpp
+++ b/drape_frontend/user_mark_generator.hpp
@@ -1,22 +1,17 @@
 #pragma once
 
-#include "drape_frontend/batchers_pool.hpp"
-#include "drape_frontend/tile_utils.hpp"
+#include "drape_frontend/tile_key.hpp"
 #include "drape_frontend/user_mark_shapes.hpp"
 
-#include "drape/drape_global.hpp"
 #include "drape/pointers.hpp"
 
-#include "indexer/scales.hpp"
-
-#include <array>
 #include <map>
+#include <set>
 #include <string>
 #include <vector>
 
 namespace df
 {
-
 using GroupID = uint32_t;
 using MarkGroups = std::map<GroupID, drape_ptr<UserMarksRenderCollection>>;
 using LineGroups = std::map<GroupID, drape_ptr<UserLinesRenderCollection>>;
@@ -40,6 +35,8 @@ public:
   void SetUserMarks(GroupID groupId, drape_ptr<UserMarksRenderCollection> && marks);
   void SetUserLines(GroupID groupId, drape_ptr<UserLinesRenderCollection> && lines);
 
+  void ClearUserMarks(GroupID groupId);
+
   void SetGroupVisibility(GroupID groupId, bool isVisible);
 
   void GenerateUserMarksGeometry(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures);
@@ -51,7 +48,7 @@ private:
   ref_ptr<IndexesCollection> GetIndexesCollection(TileKey const & tileKey, GroupID groupId);
   void CleanIndex();
 
-  std::map<GroupID, bool> m_groupsVisibility;
+  std::unordered_set<GroupID> m_groupsVisibility;
 
   MarkGroups m_marks;
   LineGroups m_lines;
@@ -60,5 +57,4 @@ private:
 
   TFlushFn m_flushFn;
 };
-
 }  // namespace df
diff --git a/drape_frontend/user_mark_shapes.cpp b/drape_frontend/user_mark_shapes.cpp
index 2e0b934b22..3030dcec31 100644
--- a/drape_frontend/user_mark_shapes.cpp
+++ b/drape_frontend/user_mark_shapes.cpp
@@ -76,70 +76,14 @@ struct UserPointVertex : gpu::BaseVertex
   float m_isAnim;
 };
 
-using UPV = UserPointVertex;
-/*
-void CacheUserLines(UserMarksProvider const * provider, ref_ptr<dp::TextureManager> textures,
-                    TUserMarkShapes & outShapes)
-{
-  int const kZoomLevel = 10;
-  map<TileKey, vector<pair<UserLineMark const *, m2::SharedSpline>>> userLines;
-  for (size_t i = 0; i < provider->GetUserLineCount(); ++i)
-  {
-    UserLineMark const * line = provider->GetUserLineMark(i);
-    size_t const pointCount = line->GetPointCount();
-
-    vector<m2::PointD> points;
-    m2::RectD rect;
-    points.reserve(pointCount);
-    for (size_t i = 0; i < pointCount; ++i)
-    {
-      points.push_back(line->GetPoint(i));
-      rect.Add(points.back());
-    }
-
-    TileKey const tileKey = GetTileKeyByPoint(rect.Center(), kZoomLevel);
-    userLines[tileKey].push_back(make_pair(line, m2::SharedSpline(points)));
-  }
-
-  int const kBatchSize = 5000;
-  for (auto it = userLines.begin(); it != userLines.end(); ++it)
-  {
-    TileKey const & key = it->first;
-    dp::Batcher batcher(kBatchSize, kBatchSize);
-    dp::SessionGuard guard(batcher, [&key, &outShapes](dp::GLState const & state,
-                                                       drape_ptr<dp::RenderBucket> && b)
-    {
-      outShapes.emplace_back(UserMarksRenderData(state, move(b), key));
-    });
-    for (auto const & lineData : it->second)
-    {
-      UserLineMark const * line = lineData.first;
-      for (size_t layerIndex = 0; layerIndex < line->GetLayerCount(); ++layerIndex)
-      {
-        LineViewParams params;
-        params.m_tileCenter = key.GetGlobalRect().Center();
-        params.m_baseGtoPScale = 1.0f;
-        params.m_cap = dp::RoundCap;
-        params.m_join = dp::RoundJoin;
-        params.m_color = line->GetColor(layerIndex);
-        params.m_depth = line->GetLayerDepth(layerIndex);
-        params.m_width = line->GetWidth(layerIndex);
-        params.m_minVisibleScale = 1;
-        params.m_rank = 0;
-
-        LineShape(lineData.second, params).Draw(make_ref(&batcher), textures);
-      }
-    }
-  }
-}
-*/
 } // namespace
 
-// static
-void UserMarkShape::Draw(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
-                         UserMarksRenderCollection const & renderParams, MarkIndexesCollection const & indexes,
-                         TUserMarksRenderData & renderData)
+void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
+                    UserMarksRenderCollection const & renderParams, MarkIndexesCollection const & indexes,
+                    TUserMarksRenderData & renderData)
 {
+  using UPV = UserPointVertex;
+
   uint32_t const vertexCount = static_cast<uint32_t>(indexes.size()) * dp::Batcher::VertexPerQuad;
   uint32_t const indicesCount = static_cast<uint32_t>(indexes.size()) * dp::Batcher::IndexPerQuad;
   buffer_vector<UPV, 128> buffer;
@@ -198,11 +142,68 @@ void UserMarkShape::Draw(TileKey const & tileKey, ref_ptr<dp::TextureManager> te
   batcher.InsertListOfStrip(state, make_ref(&attribProvider), dp::Batcher::VertexPerQuad);
 }
 
-// static
-void UserLineShape::Draw(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
-                         UserLinesRenderCollection const & renderParams, LineIndexesCollection const & indexes,
-                         TUserMarksRenderData & renderData)
+void CacheUserLines(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
+                    UserLinesRenderCollection const & renderParams, LineIndexesCollection const & indexes,
+                    TUserMarksRenderData & renderData)
 {
+  // TODO: Refactor old caching to the new scheme.
 }
 
+/*
+void CacheUserLines(UserMarksProvider const * provider, ref_ptr<dp::TextureManager> textures,
+                    TUserMarkShapes & outShapes)
+{
+  int const kZoomLevel = 10;
+  map<TileKey, vector<pair<UserLineMark const *, m2::SharedSpline>>> userLines;
+  for (size_t i = 0; i < provider->GetUserLineCount(); ++i)
+  {
+    UserLineMark const * line = provider->GetUserLineMark(i);
+    size_t const pointCount = line->GetPointCount();
+
+    vector<m2::PointD> points;
+    m2::RectD rect;
+    points.reserve(pointCount);
+    for (size_t i = 0; i < pointCount; ++i)
+    {
+      points.push_back(line->GetPoint(i));
+      rect.Add(points.back());
+    }
+
+    TileKey const tileKey = GetTileKeyByPoint(rect.Center(), kZoomLevel);
+    userLines[tileKey].push_back(make_pair(line, m2::SharedSpline(points)));
+  }
+
+  int const kBatchSize = 5000;
+  for (auto it = userLines.begin(); it != userLines.end(); ++it)
+  {
+    TileKey const & key = it->first;
+    dp::Batcher batcher(kBatchSize, kBatchSize);
+    dp::SessionGuard guard(batcher, [&key, &outShapes](dp::GLState const & state,
+                                                       drape_ptr<dp::RenderBucket> && b)
+    {
+      outShapes.emplace_back(UserMarksRenderData(state, move(b), key));
+    });
+    for (auto const & lineData : it->second)
+    {
+      UserLineMark const * line = lineData.first;
+      for (size_t layerIndex = 0; layerIndex < line->GetLayerCount(); ++layerIndex)
+      {
+        LineViewParams params;
+        params.m_tileCenter = key.GetGlobalRect().Center();
+        params.m_baseGtoPScale = 1.0f;
+        params.m_cap = dp::RoundCap;
+        params.m_join = dp::RoundJoin;
+        params.m_color = line->GetColor(layerIndex);
+        params.m_depth = line->GetLayerDepth(layerIndex);
+        params.m_width = line->GetWidth(layerIndex);
+        params.m_minVisibleScale = 1;
+        params.m_rank = 0;
+
+        LineShape(lineData.second, params).Draw(make_ref(&batcher), textures);
+      }
+    }
+  }
+}
+*/
+
 } // namespace df
diff --git a/drape_frontend/user_mark_shapes.hpp b/drape_frontend/user_mark_shapes.hpp
index 36fc58bcfc..c9d03a0a44 100644
--- a/drape_frontend/user_mark_shapes.hpp
+++ b/drape_frontend/user_mark_shapes.hpp
@@ -58,19 +58,12 @@ struct UserMarkRenderData
 
 using TUserMarksRenderData = std::vector<UserMarkRenderData>;
 
-class UserMarkShape
-{
-public:
-  static void Draw(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
-                   UserMarksRenderCollection const & renderParams, MarkIndexesCollection const & indexes,
-                   TUserMarksRenderData & renderData);
-};
+void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
+                    UserMarksRenderCollection const & renderParams, MarkIndexesCollection const & indexes,
+                    TUserMarksRenderData & renderData);
 
-class UserLineShape
-{
-public:
-  static void Draw(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures, UserLinesRenderCollection const & renderParams,
-                   LineIndexesCollection const & indexes, TUserMarksRenderData & renderData);
-};
+void CacheUserLines(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
+                    UserLinesRenderCollection const & renderParams, LineIndexesCollection const & indexes,
+                    TUserMarksRenderData & renderData);
 
 } // namespace df
diff --git a/xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj b/xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj
index 41e45cd935..7984d4540d 100644
--- a/xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj
+++ b/xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj
@@ -216,6 +216,8 @@
 		BB035F6F1E3A2AAE00519962 /* drape_measurer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BB035F6D1E3A2AAE00519962 /* drape_measurer.cpp */; };
 		BB035F701E3A2AAE00519962 /* drape_measurer.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BB035F6E1E3A2AAE00519962 /* drape_measurer.hpp */; };
 		BBD8F8791E96A51A00BAEB72 /* drape_hints.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BBD8F8781E96A51A00BAEB72 /* drape_hints.hpp */; };
+		BBD9E2D31F009D9E00DF189A /* user_mark_generator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BBD9E2D11F009D9E00DF189A /* user_mark_generator.cpp */; };
+		BBD9E2D41F009D9E00DF189A /* user_mark_generator.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BBD9E2D21F009D9E00DF189A /* user_mark_generator.hpp */; };
 		EB2B77FF1EEDD418002697B6 /* metaline_manager.cpp in Sources */ = {isa = PBXBuildFile; fileRef = EB2B77FD1EEDD418002697B6 /* metaline_manager.cpp */; };
 		EB2B78001EEDD418002697B6 /* metaline_manager.hpp in Headers */ = {isa = PBXBuildFile; fileRef = EB2B77FE1EEDD418002697B6 /* metaline_manager.hpp */; };
 		EB2B78031EEDD439002697B6 /* read_metaline_task.cpp in Sources */ = {isa = PBXBuildFile; fileRef = EB2B78011EEDD439002697B6 /* read_metaline_task.cpp */; };
@@ -496,6 +498,8 @@
 		BB035F6D1E3A2AAE00519962 /* drape_measurer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = drape_measurer.cpp; sourceTree = "<group>"; };
 		BB035F6E1E3A2AAE00519962 /* drape_measurer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = drape_measurer.hpp; sourceTree = "<group>"; };
 		BBD8F8781E96A51A00BAEB72 /* drape_hints.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = drape_hints.hpp; sourceTree = "<group>"; };
+		BBD9E2D11F009D9E00DF189A /* user_mark_generator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = user_mark_generator.cpp; sourceTree = "<group>"; };
+		BBD9E2D21F009D9E00DF189A /* user_mark_generator.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = user_mark_generator.hpp; sourceTree = "<group>"; };
 		EB2B77FD1EEDD418002697B6 /* metaline_manager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = metaline_manager.cpp; sourceTree = "<group>"; };
 		EB2B77FE1EEDD418002697B6 /* metaline_manager.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = metaline_manager.hpp; sourceTree = "<group>"; };
 		EB2B78011EEDD439002697B6 /* read_metaline_task.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = read_metaline_task.cpp; sourceTree = "<group>"; };
@@ -741,6 +745,8 @@
 				670947861BDF9BE0005014C0 /* tile_utils.hpp */,
 				670947871BDF9BE0005014C0 /* user_event_stream.cpp */,
 				670947881BDF9BE0005014C0 /* user_event_stream.hpp */,
+				BBD9E2D11F009D9E00DF189A /* user_mark_generator.cpp */,
+				BBD9E2D21F009D9E00DF189A /* user_mark_generator.hpp */,
 				670947891BDF9BE0005014C0 /* user_mark_shapes.cpp */,
 				6709478A1BDF9BE0005014C0 /* user_mark_shapes.hpp */,
 				6709478B1BDF9BE0005014C0 /* user_marks_provider.cpp */,
@@ -953,6 +959,7 @@
 				452C9EE51CEDCF3200A55E57 /* sequence_animation.hpp in Headers */,
 				670948771BDF9C7F005014C0 /* glyph_cache_impl.hpp in Headers */,
 				670947A11BDF9BE1005014C0 /* message_subclasses.hpp in Headers */,
+				BBD9E2D41F009D9E00DF189A /* user_mark_generator.hpp in Headers */,
 				670947C51BDF9BE1005014C0 /* text_handle.hpp in Headers */,
 				670947D71BDF9BE1005014C0 /* user_event_stream.hpp in Headers */,
 				6709479E1BDF9BE1005014C0 /* message_acceptor.hpp in Headers */,
@@ -1051,6 +1058,7 @@
 				56BF56DA1C7608C0006DD7CB /* choose_position_mark.cpp in Sources */,
 				67E91C751BDFC85E005CEE88 /* feature_processor.cpp in Sources */,
 				6743D36D1C3A9F090095054B /* arrow3d.cpp in Sources */,
+				BBD9E2D31F009D9E00DF189A /* user_mark_generator.cpp in Sources */,
 				670E393A1C46C59000E9C0A6 /* batch_merge_helper.cpp in Sources */,
 				452C9EDA1CEDCF3200A55E57 /* interpolators.cpp in Sources */,
 				451A2A821EE8464E003E05A4 /* circles_pack_shape.cpp in Sources */,