[fdrape] [Booking] Make Symbol, ColoredSymbol, PoiSymbol, Text of UserPointMark sensitive to tap MAPSME-14544

19 files changed, 224 insertions, 118 deletions

diff --git a/drape/overlay_handle.hpp b/drape/overlay_handle.hpp
index c050988eb1..4d17405ecc 100644
--- a/drape/overlay_handle.hpp
+++ b/drape/overlay_handle.hpp
@@ -1,17 +1,19 @@
 #pragma once
 
+#include "drape/attribute_buffer_mutator.hpp"
+#include "drape/binding_info.hpp"
 #include "drape/drape_diagnostics.hpp"
 #include "drape/drape_global.hpp"
-#include "drape/binding_info.hpp"
 #include "drape/index_buffer_mutator.hpp"
 #include "drape/index_storage.hpp"
-#include "drape/attribute_buffer_mutator.hpp"
+
+#include "kml/type_utils.hpp"
 
 #include "indexer/feature_decl.hpp"
 
-#include "geometry/screenbase.hpp"
 #include "geometry/point2d.hpp"
 #include "geometry/rect2d.hpp"
+#include "geometry/screenbase.hpp"
 
 #include "base/buffer_vector.hpp"
 
@@ -19,6 +21,7 @@
 #include <string>
 #include <utility>
 #include <vector>
+#include <tuple>
 
 namespace dp
 {
@@ -40,20 +43,32 @@ uint64_t constexpr kPriorityMaskAll = kPriorityMaskZoomLevel |
 struct OverlayID
 {
   FeatureID m_featureId;
-  m2::PointI m_tileCoords;
-  uint32_t m_index;
+  kml::MarkId m_markId = kml::kInvalidMarkId;
+  m2::PointI m_tileCoords{-1, -1};
+  uint32_t m_index = 0;
 
-  OverlayID(FeatureID const & featureId)
-    : m_featureId(featureId), m_tileCoords(-1, -1), m_index(0)
+  OverlayID() = default;
+
+  explicit OverlayID(FeatureID const & featureId)
+    : m_featureId(featureId)
   {}
-  OverlayID(FeatureID const & featureId, m2::PointI const & tileCoords, uint32_t index)
-    : m_featureId(featureId), m_tileCoords(tileCoords), m_index(index)
+
+  OverlayID(FeatureID const & featureId, kml::MarkId markId, m2::PointI const & tileCoords,
+            uint32_t index)
+    : m_featureId(featureId)
+    , m_markId(markId)
+    , m_tileCoords(tileCoords)
+    , m_index(index)
   {}
 
+  auto AsTupleRef() const
+  {
+    return std::tie(m_featureId, m_markId, m_tileCoords, m_index);
+  }
+
   bool operator==(OverlayID const & overlayId) const
   {
-    return m_featureId == overlayId.m_featureId && m_tileCoords == overlayId.m_tileCoords &&
-           m_index == overlayId.m_index;
+    return AsTupleRef() == overlayId.AsTupleRef();
   }
 
   bool operator!=(OverlayID const & overlayId) const
@@ -63,26 +78,12 @@ struct OverlayID
 
   bool operator<(OverlayID const & overlayId) const
   {
-    if (m_featureId == overlayId.m_featureId)
-    {
-      if (m_tileCoords == overlayId.m_tileCoords)
-        return m_index < overlayId.m_index;
-
-      return m_tileCoords < overlayId.m_tileCoords;
-    }
-    return m_featureId < overlayId.m_featureId;
+    return AsTupleRef() < overlayId.AsTupleRef();
   }
 
   bool operator>(OverlayID const & overlayId) const
   {
-    if (m_featureId == overlayId.m_featureId)
-    {
-      if (m_tileCoords == overlayId.m_tileCoords)
-        return m_index > overlayId.m_index;
-
-      return !(m_tileCoords < overlayId.m_tileCoords);
-    }
-    return !(m_featureId < overlayId.m_featureId);
+    return overlayId < *this;
   }
 };
 
diff --git a/drape/overlay_tree.cpp b/drape/overlay_tree.cpp
index f204051cf1..bc98f4ee86 100644
--- a/drape/overlay_tree.cpp
+++ b/drape/overlay_tree.cpp
@@ -214,7 +214,7 @@ void OverlayTree::InsertHandle(ref_ptr<OverlayHandle> handle, int currentRank,
   ASSERT(IsNeedUpdate(), ());
 
 #ifdef DEBUG_OVERLAYS_OUTPUT
-  string str = handle->GetOverlayDebugInfo();
+  std::string str = handle->GetOverlayDebugInfo();
   if (!str.empty())
     LOG(LINFO, (str));
 #endif
diff --git a/drape_frontend/apply_feature_functors.cpp b/drape_frontend/apply_feature_functors.cpp
index 910126205e..2efaff5d65 100644
--- a/drape_frontend/apply_feature_functors.cpp
+++ b/drape_frontend/apply_feature_functors.cpp
@@ -438,7 +438,7 @@ void BaseApplyFeature::ExtractCaptionParams(CaptionDefProto const * primaryProto
   CaptionDefProtoToFontDecl(primaryProto, decl);
 
   params.m_depth = depth;
-  params.m_featureID = m_id;
+  params.m_featureId = m_id;
 
   auto & titleDecl = params.m_titleDecl;
   titleDecl.m_anchor = GetAnchor(primaryProto);
@@ -580,7 +580,8 @@ void ApplyPointFeature::Finish(ref_ptr<dp::TextureManager> texMng)
   double const mainScale = df::VisualParams::Instance().GetVisualScale();
   if (hasPOI)
   {
-    PoiSymbolViewParams params(m_id);
+    PoiSymbolViewParams params;
+    params.m_featureId = m_id;
     params.m_tileCenter = m_tileRect.Center();
     params.m_depthTestEnabled = m_depthLayer != DepthLayer::NavigationLayer &&
       m_depthLayer != DepthLayer::OverlayLayer;
@@ -630,7 +631,7 @@ void ApplyPointFeature::Finish(ref_ptr<dp::TextureManager> texMng)
   if (m_isUGC)
   {
     df::ColoredSymbolViewParams params;
-    params.m_featureID = m_id;
+    params.m_featureId = m_id;
     params.m_tileCenter = m_tileRect.Center();
     params.m_color = dp::Color::Yellow();
     params.m_radiusInPixels = hasPOI ? static_cast<float>(symbolSize.x / 2.0 + mainScale * 3)
@@ -1061,7 +1062,7 @@ void ApplyLineFeatureAdditional::GetRoadShieldsViewParams(ref_ptr<dp::TextureMan
   textParams.m_depthLayer = DepthLayer::OverlayLayer;
   textParams.m_minVisibleScale = kShieldMinVisibleZoomLevel;
   textParams.m_rank = m_rank;
-  textParams.m_featureID = m_id;
+  textParams.m_featureId = m_id;
   textParams.m_titleDecl.m_anchor = anchor;
   textParams.m_titleDecl.m_primaryText = roadNumber;
   textParams.m_titleDecl.m_primaryTextFont = font;
@@ -1085,7 +1086,7 @@ void ApplyLineFeatureAdditional::GetRoadShieldsViewParams(ref_ptr<dp::TextureMan
   if (IsColoredRoadShield(shield))
   {
     // Generated symbol properties.
-    symbolParams.m_featureID = m_id;
+    symbolParams.m_featureId = m_id;
     symbolParams.m_tileCenter = m_tileRect.Center();
     symbolParams.m_depthTestEnabled = true;
     symbolParams.m_depth = m_depth;
@@ -1199,7 +1200,7 @@ void ApplyLineFeatureAdditional::Finish(ref_ptr<dp::TextureManager> texMng,
     CaptionDefProtoToFontDecl(m_captionRule, fontDecl);
     PathTextViewParams params;
     params.m_tileCenter = m_tileRect.Center();
-    params.m_featureID = m_id;
+    params.m_featureId = m_id;
     params.m_depth = m_depth;
     params.m_minVisibleScale = m_minVisibleScale;
     params.m_rank = m_rank;
@@ -1259,7 +1260,8 @@ void ApplyLineFeatureAdditional::Finish(ref_ptr<dp::TextureManager> texMng,
   {
     TextViewParams textParams;
     ColoredSymbolViewParams symbolParams;
-    PoiSymbolViewParams poiParams(m_id);
+    PoiSymbolViewParams poiParams;
+    poiParams.m_featureId = m_id;
     m2::PointD shieldPixelSize;
     GetRoadShieldsViewParams(texMng, shield, shieldIndex, static_cast<uint8_t>(roadShields.size()),
                              textParams, symbolParams, poiParams, shieldPixelSize);
diff --git a/drape_frontend/circles_pack_shape.cpp b/drape_frontend/circles_pack_shape.cpp
index 1d433acb61..b35c1cb46b 100644
--- a/drape_frontend/circles_pack_shape.cpp
+++ b/drape_frontend/circles_pack_shape.cpp
@@ -63,7 +63,8 @@ dp::BindingInfo const & GetCirclesPackDynamicBindingInfo()
 }  // namespace
 
 CirclesPackHandle::CirclesPackHandle(size_t pointsCount)
-  : OverlayHandle(FeatureID(), dp::Anchor::Center, 0 /* priority */, 1 /* minVisibleScale */, false)
+  : OverlayHandle(dp::OverlayID{}, dp::Anchor::Center, 0 /* priority */, 1 /* minVisibleScale */,
+                  false /* isBillboard */)
   , m_needUpdate(false)
 {
   m_buffer.resize(pointsCount * dp::Batcher::VertexPerQuad);
diff --git a/drape_frontend/colored_symbol_shape.cpp b/drape_frontend/colored_symbol_shape.cpp
index e612482dc3..b1e435273f 100644
--- a/drape_frontend/colored_symbol_shape.cpp
+++ b/drape_frontend/colored_symbol_shape.cpp
@@ -272,9 +272,9 @@ void ColoredSymbolShape::Draw(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::
   if (buffer.empty())
     return;
 
-  auto const overlayId = dp::OverlayID(m_params.m_featureID, m_tileCoords, m_textIndex);
-  std::string const debugName = strings::to_string(m_params.m_featureID.m_index) + "-" +
-                                strings::to_string(m_textIndex);
+  dp::OverlayID overlayId(m_params.m_featureId, m_params.m_markId, m_tileCoords, m_textIndex);
+  std::string const debugName =
+      strings::to_string(m_params.m_featureId.m_index) + "-" + strings::to_string(m_textIndex);
 
   drape_ptr<dp::OverlayHandle> handle;
   if (m_needOverlay)
diff --git a/drape_frontend/drape_engine.cpp b/drape_frontend/drape_engine.cpp
index f93fb10e5a..22447ad8ff 100644
--- a/drape_frontend/drape_engine.cpp
+++ b/drape_frontend/drape_engine.cpp
@@ -922,6 +922,7 @@ void DrapeEngine::EnableDebugRectRendering(bool enabled)
 drape_ptr<UserMarkRenderParams> DrapeEngine::GenerateMarkRenderInfo(UserPointMark const * mark)
 {
   auto renderInfo = make_unique_dp<UserMarkRenderParams>();
+  renderInfo->m_markId = mark->GetId();
   renderInfo->m_anchor = mark->GetAnchor();
   renderInfo->m_depthTestEnabled = mark->GetDepthTestEnabled();
   if (mark->GetDepth() != UserPointMark::kInvalidDepth)
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index 837b283a4f..3e8c493602 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -1273,7 +1273,7 @@ void FrontendRenderer::OnCompassTapped()
   m_selectionTrackInfo.reset();
 }
 
-FeatureID FrontendRenderer::GetVisiblePOI(m2::PointD const & pixelPoint)
+std::pair<FeatureID, kml::MarkId> FrontendRenderer::GetVisiblePOI(m2::PointD const & pixelPoint)
 {
   double halfSize = VisualParams::Instance().GetTouchRectRadius();
   m2::PointD sizePoint(halfSize, halfSize);
@@ -1281,28 +1281,41 @@ FeatureID FrontendRenderer::GetVisiblePOI(m2::PointD const & pixelPoint)
   return GetVisiblePOI(selectRect);
 }
 
-FeatureID FrontendRenderer::GetVisiblePOI(m2::RectD const & pixelRect)
+std::pair<FeatureID, kml::MarkId> FrontendRenderer::GetVisiblePOI(m2::RectD const & pixelRect)
 {
   m2::PointD pt = pixelRect.Center();
-  dp::TOverlayContainer selectResult;
   ScreenBase const & screen = m_userEventStream.GetCurrentScreen();
   if (m_overlayTree->IsNeedUpdate())
     BuildOverlayTree(screen);
-  m_overlayTree->Select(pixelRect, selectResult);
 
-  double dist = std::numeric_limits<double>::max();
-  FeatureID featureID;
+  dp::TOverlayContainer selectResult;
+
+  auto selectionRect = pixelRect;
+  constexpr double kTapRectFactor = 0.25;  // make tap rect size smaller for extended objects
+  selectionRect.Scale(kTapRectFactor);
+  SearchInNonDisplacedUserMarksLayer(screen, DepthLayer::SearchMarkLayer, selectionRect, selectResult);
+
+  if (selectResult.empty())
+    m_overlayTree->Select(pixelRect, selectResult);
+
+  if (selectResult.empty())
+    return {};
+
+  double minSquaredDist = std::numeric_limits<double>::infinity();
+  ref_ptr<dp::OverlayHandle> closestOverlayHandle;
   for (ref_ptr<dp::OverlayHandle> handle : selectResult)
   {
-    double const curDist = pt.SquaredLength(handle->GetPivot(screen, screen.isPerspective()));
-    if (curDist < dist)
+    double const curSquaredDist = pt.SquaredLength(handle->GetPivot(screen, screen.isPerspective()));
+    if (curSquaredDist < minSquaredDist)
     {
-      dist = curDist;
-      featureID = handle->GetOverlayID().m_featureId;
+      minSquaredDist = curSquaredDist;
+      closestOverlayHandle = handle;
     }
   }
+  CHECK(closestOverlayHandle, ());
 
-  return featureID;
+  auto const & overlayId = closestOverlayHandle->GetOverlayID();
+  return {overlayId.m_featureId, overlayId.m_markId};
 }
 
 void FrontendRenderer::PullToBoundArea(bool randomPlace, bool applyZoom)
@@ -2019,7 +2032,8 @@ void FrontendRenderer::OnTap(m2::PointD const & pt, bool isLongTap)
   }
 
   ASSERT(m_tapEventInfoHandler != nullptr, ());
-  m_tapEventInfoHandler({mercator, isLongTap, isMyPosition, GetVisiblePOI(selectRect)});
+  auto [featureId, markId] = GetVisiblePOI(selectRect);
+  m_tapEventInfoHandler({mercator, isLongTap, isMyPosition, featureId, markId});
 }
 
 void FrontendRenderer::OnForceTap(m2::PointD const & pt)
@@ -2661,6 +2675,37 @@ void FrontendRenderer::ScheduleOverlayCollecting()
   });
 }
 
+void FrontendRenderer::SearchInNonDisplacedUserMarksLayer(ScreenBase const & modelView,
+                                                          DepthLayer layerId,
+                                                          m2::RectD const & selectionRect,
+                                                          dp::TOverlayContainer & result)
+{
+  auto & layer = m_layers[static_cast<size_t>(layerId)];
+  layer.Sort(nullptr);
+  for (drape_ptr<RenderGroup> & group : layer.m_renderGroups)
+  {
+    group->SetOverlayVisibility(true);
+    group->Update(modelView);
+    group->ForEachOverlay(
+      [&modelView, &result, selectionRect = m2::RectF(selectionRect)](ref_ptr<dp::OverlayHandle> const & h)
+      {
+        if (h->GetOverlayID().m_featureId.IsValid())
+        {
+          dp::OverlayHandle::Rects shapes;
+          h->GetPixelShape(modelView, modelView.isPerspective(), shapes);
+          for (m2::RectF const & shape : shapes)
+          {
+            if (selectionRect.IsIntersect(shape))
+            {
+              result.push_back(h);
+              break;
+            }
+          }
+        }
+      });
+  }
+}
+
 void FrontendRenderer::RenderLayer::Sort(ref_ptr<dp::OverlayTree> overlayTree)
 {
   if (!m_isDirty)
diff --git a/drape_frontend/frontend_renderer.hpp b/drape_frontend/frontend_renderer.hpp
index 92e008430d..614f742957 100755
--- a/drape_frontend/frontend_renderer.hpp
+++ b/drape_frontend/frontend_renderer.hpp
@@ -23,6 +23,8 @@
 #include "drape_frontend/transit_scheme_renderer.hpp"
 #include "drape_frontend/user_event_stream.hpp"
 
+#include "kml/type_utils.hpp"
+
 #include "shaders/program_manager.hpp"
 
 #include "drape/overlay_tree.hpp"
@@ -63,6 +65,7 @@ struct TapInfo
   bool const m_isLong;
   bool const m_isMyPositionTapped;
   FeatureID const m_featureTapped;
+  kml::MarkId const m_markId;
 
   static m2::AnyRectD GetDefaultTapRect(m2::PointD const & mercator, ScreenBase const & screen);
   static m2::AnyRectD GetBookmarkTapRect(m2::PointD const & mercator, ScreenBase const & screen);
@@ -266,8 +269,8 @@ private:
 
   void OnCompassTapped();
 
-  FeatureID GetVisiblePOI(m2::PointD const & pixelPoint);
-  FeatureID GetVisiblePOI(m2::RectD const & pixelRect);
+  std::pair<FeatureID, kml::MarkId> GetVisiblePOI(m2::PointD const & pixelPoint);
+  std::pair<FeatureID, kml::MarkId> GetVisiblePOI(m2::RectD const & pixelRect);
 
   void PullToBoundArea(bool randomPlace, bool applyZoom);
 
@@ -282,6 +285,10 @@ private:
 
   void ScheduleOverlayCollecting();
 
+  void SearchInNonDisplacedUserMarksLayer(ScreenBase const & modelView, DepthLayer layerId,
+                                          m2::RectD const & selectionRect,
+                                          dp::TOverlayContainer & result);
+
   drape_ptr<gpu::ProgramManager> m_gpuProgramManager;
 
   std::array<RenderLayer, static_cast<size_t>(DepthLayer::LayersCount)> m_layers;
diff --git a/drape_frontend/gui/shape.cpp b/drape_frontend/gui/shape.cpp
index 3cacc28d96..d66dd527eb 100644
--- a/drape_frontend/gui/shape.cpp
+++ b/drape_frontend/gui/shape.cpp
@@ -13,7 +13,8 @@
 namespace gui
 {
 Handle::Handle(uint32_t id, dp::Anchor anchor, m2::PointF const & pivot, m2::PointF const & size)
-  : dp::OverlayHandle(FeatureID(MwmSet::MwmId(), id), anchor, 0 /* priority */, 1 /* minVisibleScale */, false)
+  : dp::OverlayHandle(dp::OverlayID(FeatureID(MwmSet::MwmId{}, id)), anchor, 0 /* priority */,
+                      1 /* minVisibleScale */, false /* isBillboard */)
   , m_pivot(glsl::ToVec2(pivot))
   , m_size(size)
 {}
diff --git a/drape_frontend/path_text_shape.cpp b/drape_frontend/path_text_shape.cpp
index 7bc4e4cb78..06d9624353 100644
--- a/drape_frontend/path_text_shape.cpp
+++ b/drape_frontend/path_text_shape.cpp
@@ -155,8 +155,8 @@ void PathTextShape::DrawPathTextOutlined(ref_ptr<dp::GraphicsContext> context,
 drape_ptr<dp::OverlayHandle> PathTextShape::CreateOverlayHandle(uint32_t textIndex,
                                                                 ref_ptr<dp::TextureManager> textures) const
 {
-  dp::OverlayID const overlayId = dp::OverlayID(m_params.m_featureID, m_tileCoords,
-                                                m_baseTextIndex + textIndex);
+  dp::OverlayID overlayId(m_params.m_featureId, m_params.m_markId,
+                          m_tileCoords, m_baseTextIndex + textIndex);
   auto const layout = m_context->GetLayout();
   auto const priority = GetOverlayPriority(textIndex, layout->GetText().size());
   return make_unique_dp<PathTextHandle>(overlayId, m_context, m_params.m_depth,
diff --git a/drape_frontend/poi_symbol_shape.cpp b/drape_frontend/poi_symbol_shape.cpp
index e40d299980..3003769516 100644
--- a/drape_frontend/poi_symbol_shape.cpp
+++ b/drape_frontend/poi_symbol_shape.cpp
@@ -9,8 +9,9 @@
 #include "drape/texture_manager.hpp"
 #include "drape/utils/vertex_decl.hpp"
 
+#include "base/buffer_vector.hpp"
+
 #include <utility>
-#include <vector>
 
 namespace
 {
@@ -36,23 +37,15 @@ glsl::vec2 ShiftNormal(glsl::vec2 const & n, df::PoiSymbolViewParams const & par
   return result;
 }
 
-template <typename TVertex>
-void Batch(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Batcher> batcher,
-           drape_ptr<dp::OverlayHandle> && handle, glsl::vec4 const & position,
-           df::PoiSymbolViewParams const & params,
-           dp::TextureManager::SymbolRegion const & symbolRegion,
-           dp::TextureManager::ColorRegion const & colorRegion)
+template <typename TCreateOverlayHandle>
+void SolidBatch(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Batcher> batcher,
+                TCreateOverlayHandle && createOverlayHandle, glsl::vec4 const & position,
+                df::PoiSymbolViewParams const & params,
+                dp::TextureManager::SymbolRegion const & symbolRegion,
+                dp::TextureManager::ColorRegion const & colorRegion)
 {
-  ASSERT(0, ("Can not be used without specialization"));
-}
+  UNUSED_VALUE(colorRegion);
 
-template <>
-void Batch<SV>(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Batcher> batcher,
-               drape_ptr<dp::OverlayHandle> && handle, glsl::vec4 const & position,
-               df::PoiSymbolViewParams const & params,
-               dp::TextureManager::SymbolRegion const & symbolRegion,
-               dp::TextureManager::ColorRegion const & colorRegion)
-{
   m2::PointF const symbolRegionSize = symbolRegion.GetPixelSize();
   m2::PointF pixelSize = symbolRegionSize;
   if (pixelSize.x < params.m_pixelWidth)
@@ -60,8 +53,7 @@ void Batch<SV>(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Batcher> batche
   m2::PointF const halfSize = pixelSize * 0.5f;
   m2::RectF const & texRect = symbolRegion.GetTexRect();
 
-  std::vector<SV> vertexes;
-  vertexes.reserve(params.m_pixelWidth ? 8 : 4);
+  buffer_vector<SV, 8> vertexes;
   vertexes.emplace_back(position,
                         ShiftNormal(glsl::vec2(-halfSize.x, halfSize.y), params, pixelSize),
                         glsl::vec2(texRect.minX(), texRect.maxY()));
@@ -101,15 +93,15 @@ void Batch<SV>(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Batcher> batche
 
   dp::AttributeProvider provider(1 /* streamCount */, vertexes.size());
   provider.InitStream(0 /* streamIndex */, SV::GetBindingInfo(), make_ref(vertexes.data()));
-  batcher->InsertTriangleStrip(context, state, make_ref(&provider), move(handle));
+  batcher->InsertTriangleStrip(context, state, make_ref(&provider), createOverlayHandle(vertexes));
 }
 
-template <>
-void Batch<MV>(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Batcher> batcher,
-               drape_ptr<dp::OverlayHandle> && handle, glsl::vec4 const & position,
-               df::PoiSymbolViewParams const & params,
-               dp::TextureManager::SymbolRegion const & symbolRegion,
-               dp::TextureManager::ColorRegion const & colorRegion)
+template <typename TCreateOverlayHandle>
+void MaskedBatch(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Batcher> batcher,
+                 TCreateOverlayHandle && createOverlayHandle, glsl::vec4 const & position,
+                 df::PoiSymbolViewParams const & params,
+                 dp::TextureManager::SymbolRegion const & symbolRegion,
+                 dp::TextureManager::ColorRegion const & colorRegion)
 {
   m2::PointF const symbolRegionSize = symbolRegion.GetPixelSize();
   m2::PointF pixelSize = symbolRegionSize;
@@ -119,8 +111,7 @@ void Batch<MV>(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Batcher> batche
   m2::RectF const & texRect = symbolRegion.GetTexRect();
   glsl::vec2 const maskColorCoords = glsl::ToVec2(colorRegion.GetTexRect().Center());
 
-  std::vector<MV> vertexes;
-  vertexes.reserve(params.m_pixelWidth ? 8 : 4);
+  buffer_vector<MV, 8> vertexes;
   vertexes.emplace_back(position,
                         ShiftNormal(glsl::vec2(-halfSize.x, halfSize.y), params, pixelSize),
                         glsl::vec2(texRect.minX(), texRect.maxY()), maskColorCoords);
@@ -161,7 +152,7 @@ void Batch<MV>(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Batcher> batche
 
   dp::AttributeProvider provider(1 /* streamCount */, vertexes.size());
   provider.InitStream(0 /* streamIndex */, MV::GetBindingInfo(), make_ref(vertexes.data()));
-  batcher->InsertTriangleStrip(context, state, make_ref(&provider), move(handle));
+  batcher->InsertTriangleStrip(context, state, make_ref(&provider), createOverlayHandle(vertexes));
 }
 }  // namespace
 
@@ -183,33 +174,34 @@ void PoiSymbolShape::Draw(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Batc
 
   glsl::vec2 const pt = glsl::ToVec2(ConvertToLocal(m_pt, m_params.m_tileCenter, kShapeCoordScalar));
   glsl::vec4 const position = glsl::vec4(pt, m_params.m_depth, -m_params.m_posZ);
-  m2::PointF const pixelSize = region.GetPixelSize();
 
+  auto const createOverlayHandle = [this](auto const & vertexes) -> drape_ptr<dp::OverlayHandle>
+  {
+    m2::RectD rect;
+    for (auto const & vertex : vertexes)
+      rect.Add(glsl::FromVec2(vertex.m_normal));
+    return CreateOverlayHandle(rect);
+  };
+
+  dp::TextureManager::ColorRegion maskColorRegion;
   if (m_params.m_maskColor.empty())
   {
-    Batch<SV>(context, batcher, CreateOverlayHandle(pixelSize), position, m_params, region,
-              dp::TextureManager::ColorRegion());
+    SolidBatch(context, batcher, createOverlayHandle, position, m_params, region, maskColorRegion);
   }
   else
   {
-    dp::TextureManager::ColorRegion maskColorRegion;
     textures->GetColorRegion(df::GetColorConstant(m_params.m_maskColor), maskColorRegion);
-    Batch<MV>(context, batcher, CreateOverlayHandle(pixelSize), position, m_params, region,
-              maskColorRegion);
+    MaskedBatch(context, batcher, createOverlayHandle, position, m_params, region, maskColorRegion);
   }
 }
 
-drape_ptr<dp::OverlayHandle> PoiSymbolShape::CreateOverlayHandle(m2::PointF const & pixelSize) const
+drape_ptr<dp::OverlayHandle> PoiSymbolShape::CreateOverlayHandle(m2::RectD const & pixelRect) const
 {
-  dp::OverlayID overlayId = dp::OverlayID(m_params.m_id, m_tileCoords, m_textIndex);
-  drape_ptr<dp::OverlayHandle> handle = make_unique_dp<dp::SquareHandle>(overlayId, m_params.m_anchor,
-                                                                         m_pt, m2::PointD(pixelSize),
-                                                                         m2::PointD(m_params.m_offset),
-                                                                         GetOverlayPriority(),
-                                                                         true /* isBound */,
-                                                                         m_params.m_symbolName,
-                                                                         m_params.m_minVisibleScale,
-                                                                         true /* isBillboard */);
+  dp::OverlayID overlayId(m_params.m_featureId, m_params.m_markId, m_tileCoords, m_textIndex);
+  drape_ptr<dp::OverlayHandle> handle = make_unique_dp<dp::SquareHandle>(
+      overlayId, m_params.m_anchor, m_pt, pixelRect.RightTop() - pixelRect.LeftBottom(),
+      m2::PointD(m_params.m_offset), GetOverlayPriority(), true /* isBound */,
+      m_params.m_symbolName, m_params.m_minVisibleScale, true /* isBillboard */);
   handle->SetPivotZ(m_params.m_posZ);
   handle->SetExtendingSize(m_params.m_extendingSize);
   if (m_params.m_specialDisplacement == SpecialDisplacement::UserMark ||
diff --git a/drape_frontend/poi_symbol_shape.hpp b/drape_frontend/poi_symbol_shape.hpp
index 8f07ab1541..33ecba4092 100644
--- a/drape_frontend/poi_symbol_shape.hpp
+++ b/drape_frontend/poi_symbol_shape.hpp
@@ -24,7 +24,7 @@ public:
 
 private:
   uint64_t GetOverlayPriority() const;
-  drape_ptr<dp::OverlayHandle> CreateOverlayHandle(m2::PointF const & pixelSize) const;
+  drape_ptr<dp::OverlayHandle> CreateOverlayHandle(m2::RectD const & pixelRect) const;
 
   m2::PointD const m_pt;
   PoiSymbolViewParams const m_params;
diff --git a/drape_frontend/render_group.hpp b/drape_frontend/render_group.hpp
index 2001b9c656..87fcafc62d 100755
--- a/drape_frontend/render_group.hpp
+++ b/drape_frontend/render_group.hpp
@@ -77,6 +77,17 @@ public:
   bool IsOverlay() const;
   bool IsUserMark() const;
 
+  // Warning! Has linear complexity on number of OverlayHandles in the render group.
+  template <typename ToDo>
+  void ForEachOverlay(ToDo const & todo)
+  {
+    if (CanBeDeleted())
+      return;
+
+    for (auto & renderBucket : m_renderBuckets)
+      renderBucket->ForEachOverlay(todo);
+  }
+
 private:
   std::vector<drape_ptr<dp::RenderBucket>> m_renderBuckets;
   mutable bool m_pendingOnDelete;
diff --git a/drape_frontend/shape_view_params.hpp b/drape_frontend/shape_view_params.hpp
index b1e57e97ee..0541bb4880 100644
--- a/drape_frontend/shape_view_params.hpp
+++ b/drape_frontend/shape_view_params.hpp
@@ -6,6 +6,8 @@
 #include "drape/drape_global.hpp"
 #include "drape/stipple_pen_resource.hpp"
 
+#include "kml/type_utils.hpp"
+
 #include "indexer/feature_decl.hpp"
 
 #include "geometry/point2d.hpp"
@@ -28,6 +30,9 @@ struct CommonViewParams
   int m_minVisibleScale = 0;
   uint8_t m_rank = 0;
   m2::PointD m_tileCenter;
+
+  FeatureID m_featureId;
+  kml::MarkId m_markId = kml::kInvalidMarkId;
 };
 
 enum class SpecialDisplacement : uint8_t
@@ -48,9 +53,6 @@ struct CommonOverlayViewParams : public CommonViewParams
 
 struct PoiSymbolViewParams : CommonOverlayViewParams
 {
-  PoiSymbolViewParams(FeatureID const & id) : m_id(id) {}
-
-  FeatureID m_id;
   std::string m_symbolName;
   uint32_t m_extendingSize = 0;
   float m_posZ = 0.0f;
@@ -90,9 +92,6 @@ struct LineViewParams : CommonViewParams
 
 struct TextViewParams : CommonOverlayViewParams
 {
-  TextViewParams() {}
-
-  FeatureID m_featureID;
   dp::TitleDecl m_titleDecl;
   bool m_hasArea = false;
   bool m_createdByEditor = false;
@@ -104,7 +103,6 @@ struct TextViewParams : CommonOverlayViewParams
 
 struct PathTextViewParams : CommonOverlayViewParams
 {
-  FeatureID m_featureID;
   dp::FontDecl m_textFont;
   std::string m_mainText;
   std::string m_auxText;
@@ -113,7 +111,6 @@ struct PathTextViewParams : CommonOverlayViewParams
 
 struct PathSymbolViewParams : CommonViewParams
 {
-  FeatureID m_featureID;
   std::string m_symbolName;
   float m_offset = 0.0f;
   float m_step = 0.0f;
@@ -127,7 +124,6 @@ struct ColoredSymbolViewParams : CommonOverlayViewParams
     Rectangle, Circle, RoundedRectangle
   };
 
-  FeatureID m_featureID;
   Shape m_shape = Shape::Circle;
   dp::Anchor m_anchor = dp::Center;
   dp::Color m_color;
diff --git a/drape_frontend/text_shape.cpp b/drape_frontend/text_shape.cpp
index 2e7e081f5e..a8e03eae74 100644
--- a/drape_frontend/text_shape.cpp
+++ b/drape_frontend/text_shape.cpp
@@ -330,7 +330,7 @@ void TextShape::DrawSubStringPlain(ref_ptr<dp::GraphicsContext> context,
 
   m2::PointF const & pixelSize = layout.GetPixelSize();
 
-  auto overlayId = dp::OverlayID(m_params.m_featureID, m_tileCoords, m_textIndex);
+  dp::OverlayID overlayId(m_params.m_featureId, m_params.m_markId, m_tileCoords, m_textIndex);
   drape_ptr<StraightTextHandle> handle = make_unique_dp<StraightTextHandle>(overlayId,
                                                                             layout.GetText(),
                                                                             m_params.m_titleDecl.m_anchor,
@@ -393,7 +393,7 @@ void TextShape::DrawSubStringOutlined(ref_ptr<dp::GraphicsContext> context,
 
   m2::PointF const & pixelSize = layout.GetPixelSize();
 
-  auto overlayId = dp::OverlayID(m_params.m_featureID, m_tileCoords, m_textIndex);
+  dp::OverlayID overlayId(m_params.m_featureId, m_params.m_markId, m_tileCoords, m_textIndex);
   drape_ptr<StraightTextHandle> handle = make_unique_dp<StraightTextHandle>(overlayId,
                                                                             layout.GetText(),
                                                                             m_params.m_titleDecl.m_anchor,
diff --git a/drape_frontend/transit_scheme_builder.cpp b/drape_frontend/transit_scheme_builder.cpp
index 734b66930b..8c55e93bdc 100644
--- a/drape_frontend/transit_scheme_builder.cpp
+++ b/drape_frontend/transit_scheme_builder.cpp
@@ -741,7 +741,7 @@ void TransitSchemeBuilder::GenerateTitles(ref_ptr<dp::GraphicsContext> context,
   for (auto const & title : titles)
   {
     TextViewParams textParams;
-    textParams.m_featureID = featureId;
+    textParams.m_featureId = featureId;
     textParams.m_tileCenter = pivot;
     textParams.m_titleDecl = titleDecl;
     textParams.m_titleDecl.m_primaryText = title.m_text;
@@ -760,7 +760,7 @@ void TransitSchemeBuilder::GenerateTitles(ref_ptr<dp::GraphicsContext> context,
   df::ColoredSymbolViewParams colorParams;
   colorParams.m_radiusInPixels = markerSizes.front().x * 0.5f;
   colorParams.m_color = dp::Color::Transparent();
-  colorParams.m_featureID = featureId;
+  colorParams.m_featureId = featureId;
   colorParams.m_tileCenter = pivot;
   colorParams.m_depthTestEnabled = false;
   colorParams.m_depthLayer = DepthLayer::TransitSchemeLayer;
diff --git a/drape_frontend/user_mark_shapes.cpp b/drape_frontend/user_mark_shapes.cpp
index 9ce4c4187c..4ef25be0e7 100644
--- a/drape_frontend/user_mark_shapes.cpp
+++ b/drape_frontend/user_mark_shapes.cpp
@@ -169,6 +169,8 @@ void GenerateColoredSymbolShapes(ref_ptr<dp::GraphicsContext> context, ref_ptr<d
   }
 
   ColoredSymbolViewParams params;
+  params.m_featureId = renderInfo.m_featureId;
+  params.m_markId = renderInfo.m_markId;
 
   if (renderInfo.m_coloredSymbols->m_isSymbolStub)
   {
@@ -205,7 +207,6 @@ void GenerateColoredSymbolShapes(ref_ptr<dp::GraphicsContext> context, ref_ptr<d
   if (!isTextBg)
     symbolSize = m2::PointF(std::max(coloredSize.x, symbolSize.x), std::max(coloredSize.y, symbolSize.y));
 
-  params.m_featureID = renderInfo.m_featureId;
   params.m_tileCenter = tileCenter;
   params.m_depthTestEnabled = renderInfo.m_depthTestEnabled;
   params.m_depth = renderInfo.m_depth;
@@ -234,7 +235,9 @@ void GeneratePoiSymbolShape(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Te
                             m2::PointD const & tileCenter, std::string const & symbolName,
                             m2::PointF const & symbolOffset, dp::Batcher & batcher)
 {
-  PoiSymbolViewParams params(renderInfo.m_featureId);
+  PoiSymbolViewParams params;
+  params.m_featureId = renderInfo.m_featureId;
+  params.m_markId = renderInfo.m_markId;
   params.m_tileCenter = tileCenter;
   params.m_depthTestEnabled = renderInfo.m_depthTestEnabled;
   params.m_depth = renderInfo.m_depth;
@@ -298,7 +301,8 @@ void GenerateTextShapes(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::Textur
       continue;
 
     TextViewParams params;
-    params.m_featureID = renderInfo.m_featureId;
+    params.m_featureId = renderInfo.m_featureId;
+    params.m_markId = renderInfo.m_markId;
     params.m_tileCenter = tileCenter;
     params.m_titleDecl = titleDecl;
 
@@ -390,6 +394,42 @@ std::string GetBackgroundForSymbol(std::string const & symbolName,
 }
 }  // namespace
 
+uint64_t GetOverlayPriority(UserMarkRenderParams const & renderInfo)
+{
+  // Special displacement mode.
+  if (renderInfo.m_displacement == SpecialDisplacement::SpecialMode)
+    return dp::CalculateSpecialModePriority(renderInfo.m_priority);
+
+  if (renderInfo.m_displacement == SpecialDisplacement::SpecialModeUserMark)
+    return dp::CalculateSpecialModeUserMarkPriority(renderInfo.m_priority);
+
+  if (renderInfo.m_displacement == SpecialDisplacement::UserMark)
+    return dp::CalculateUserMarkPriority(renderInfo.m_minZoom, renderInfo.m_priority);
+
+  return dp::CalculateOverlayPriority(renderInfo.m_minZoom, 0, renderInfo.m_depth);
+}
+
+drape_ptr<dp::OverlayHandle> CreateOverlayHandle(UserMarkRenderParams const & renderInfo,
+                                                 TileKey const & tileKey,
+                                                 m2::PointF const & symbolOffset,
+                                                 m2::RectD const & pixelRect)
+{
+  dp::OverlayID overlayId(renderInfo.m_featureId, renderInfo.m_markId, tileKey.GetTileCoords(),
+                          kStartUserMarkOverlayIndex + renderInfo.m_index);
+  drape_ptr<dp::OverlayHandle> handle = make_unique_dp<dp::SquareHandle>(
+      overlayId, renderInfo.m_anchor, renderInfo.m_pivot,
+      pixelRect.RightTop() - pixelRect.LeftBottom(), m2::PointD(symbolOffset),
+      GetOverlayPriority(renderInfo), true /* isBound */, "MainSymbol", renderInfo.m_minZoom,
+      true /* isBillboard */);
+  if (renderInfo.m_displacement == SpecialDisplacement::UserMark ||
+      renderInfo.m_displacement == SpecialDisplacement::SpecialModeUserMark)
+  {
+    handle->SetSpecialLayerOverlay(true);
+  }
+  handle->SetOverlayRank(dp::OverlayRank0);
+  return handle;
+}
+
 void CacheUserMarks(ref_ptr<dp::GraphicsContext> context, TileKey const & tileKey,
                     ref_ptr<dp::TextureManager> textures, kml::MarkIdCollection const & marksId,
                     UserMarksRenderCollection & renderParams, dp::Batcher & batcher)
@@ -491,6 +531,12 @@ void CacheUserMarks(ref_ptr<dp::GraphicsContext> context, TileKey const & tileKe
             glsl::ToVec4(m2::PointD(texRect.RightBottom()), m2::PointD(bgTexRect.RightBottom())),
             maskColor);
 
+        m2::RectD rect;
+        for (auto const & vertex : buffer)
+          rect.Add(glsl::FromVec2(vertex.m_normalAndAnimateOrZ.xy()));
+
+        auto overlayHandle = CreateOverlayHandle(renderInfo, tileKey, symbolOffset, rect);
+
         gpu::Program program;
         gpu::Program program3d;
         if (renderInfo.m_isMarkAboveText)
@@ -517,7 +563,8 @@ void CacheUserMarks(ref_ptr<dp::GraphicsContext> context, TileKey const & tileKe
         dp::AttributeProvider attribProvider(1, static_cast<uint32_t>(buffer.size()));
         attribProvider.InitStream(0, UPV::GetBinding(), make_ref(buffer.data()));
 
-        batcher.InsertListOfStrip(context, state, make_ref(&attribProvider), dp::Batcher::VertexPerQuad);
+        batcher.InsertListOfStrip(context, state, make_ref(&attribProvider),
+                                  std::move(overlayHandle), dp::Batcher::VertexPerQuad);
       }
     }
 
diff --git a/drape_frontend/user_mark_shapes.hpp b/drape_frontend/user_mark_shapes.hpp
index b90e9c0664..8dd3daf359 100644
--- a/drape_frontend/user_mark_shapes.hpp
+++ b/drape_frontend/user_mark_shapes.hpp
@@ -16,6 +16,7 @@ namespace df
 {
 struct UserMarkRenderParams
 {
+  kml::MarkId m_markId = kml::kInvalidMarkId;
   int m_minZoom = 1;
   int m_minTitleZoom = 1;
   m2::PointD m_pivot = m2::PointD(0.0, 0.0);
diff --git a/map/place_page_info.hpp b/map/place_page_info.hpp
index 411b4e6158..a338b7aa6c 100644
--- a/map/place_page_info.hpp
+++ b/map/place_page_info.hpp
@@ -102,6 +102,7 @@ struct BuildInfo
     , m_isLongTap(info.m_isLong)
     , m_isMyPosition(info.m_isMyPositionTapped)
     , m_featureId(info.m_featureTapped)
+    , m_userMarkId(info.m_markId)
   {}
 
   bool IsFeatureMatchingEnabled() const