Dynamic straight text offsets.

18 files changed, 375 insertions, 178 deletions

diff --git a/drape/overlay_handle.cpp b/drape/overlay_handle.cpp
index adf53b2fc0..28feed320a 100644
--- a/drape/overlay_handle.cpp
+++ b/drape/overlay_handle.cpp
@@ -205,8 +205,8 @@ SquareHandle::SquareHandle(OverlayID const & id, dp::Anchor anchor, m2::PointD c
                            uint64_t priority, bool isBound, std::string const & debugStr,
                            bool isBillboard)
   : TBase(id, anchor, priority, isBillboard)
-  , m_gbPivot(gbPivot)
   , m_pxHalfSize(pxSize.x / 2.0, pxSize.y / 2.0)
+  , m_gbPivot(gbPivot)
   , m_pxOffset(pxOffset)
   , m_isBound(isBound)
 #ifdef DEBUG_OVERLAYS_OUTPUT
@@ -243,6 +243,7 @@ void SquareHandle::GetPixelShape(ScreenBase const & screen, bool perspective, Re
 }
 
 bool SquareHandle::IsBound() const { return m_isBound; }
+
 #ifdef DEBUG_OVERLAYS_OUTPUT
 std::string SquareHandle::GetOverlayDebugInfo()
 {
diff --git a/drape/overlay_handle.hpp b/drape/overlay_handle.hpp
index 4401b7de0f..c80c942ed5 100644
--- a/drape/overlay_handle.hpp
+++ b/drape/overlay_handle.hpp
@@ -216,9 +216,11 @@ public:
   virtual std::string GetOverlayDebugInfo() override;
 #endif
 
+protected:
+  m2::PointD m_pxHalfSize;
+
 private:
   m2::PointD m_gbPivot;
-  m2::PointD m_pxHalfSize;
   m2::PointD m_pxOffset;
   bool m_isBound;
 
diff --git a/drape_frontend/colored_symbol_shape.cpp b/drape_frontend/colored_symbol_shape.cpp
index 7ba174faef..d1cc0dfc93 100644
--- a/drape_frontend/colored_symbol_shape.cpp
+++ b/drape_frontend/colored_symbol_shape.cpp
@@ -39,6 +39,37 @@ glsl::vec2 ShiftNormal(glsl::vec2 const & n, ColoredSymbolViewParams const & par
 }
 }  // namespace
 
+class DynamicSquareHandle : public dp::SquareHandle
+{
+  using TBase = dp::SquareHandle;
+
+public:
+  DynamicSquareHandle(dp::OverlayID const & id, dp::Anchor anchor, m2::PointD const & gbPivot,
+                      std::vector<m2::PointF> const & pxSizes, m2::PointD const & pxOffset,
+                      uint64_t priority, bool isBound, std::string const & debugStr,
+                      bool isBillboard)
+    : TBase(id, anchor, gbPivot, m2::PointD::Zero(), pxOffset, priority, isBound, debugStr, isBillboard)
+    , m_pxSizes(pxSizes)
+  {
+    ASSERT_GREATER(pxSizes.size(), 0, ());
+  }
+
+  bool Update(ScreenBase const & screen) override
+  {
+    double zoom = 0.0;
+    int index = 0;
+    float lerpCoef = 0.0f;
+    ExtractZoomFactors(screen, zoom, index, lerpCoef);
+    auto const size = InterpolateByZoomLevels(index, lerpCoef, m_pxSizes);
+    m_pxHalfSize.x = size.x * 0.5;
+    m_pxHalfSize.y = size.y * 0.5;
+    return true;
+  }
+
+private:
+  std::vector<m2::PointF> m_pxSizes;
+};
+
 ColoredSymbolShape::ColoredSymbolShape(m2::PointD const & mercatorPt, ColoredSymbolViewParams const & params,
                                        TileKey const & tileKey, uint32_t textIndex, bool needOverlay)
   : m_point(mercatorPt)
@@ -48,6 +79,17 @@ ColoredSymbolShape::ColoredSymbolShape(m2::PointD const & mercatorPt, ColoredSym
   , m_needOverlay(needOverlay)
 {}
 
+ColoredSymbolShape::ColoredSymbolShape(m2::PointD const & mercatorPt, ColoredSymbolViewParams const & params,
+                                       TileKey const & tileKey, uint32_t textIndex,
+                                       std::vector<m2::PointF> const & overlaySizes)
+  : m_point(mercatorPt)
+  , m_params(params)
+  , m_tileCoords(tileKey.GetTileCoords())
+  , m_textIndex(textIndex)
+  , m_needOverlay(true)
+  , m_overlaySizes(overlaySizes)
+{}
+
 void ColoredSymbolShape::Draw(ref_ptr<dp::Batcher> batcher,
                               ref_ptr<dp::TextureManager> textures) const
 {
@@ -231,13 +273,25 @@ void ColoredSymbolShape::Draw(ref_ptr<dp::Batcher> batcher,
   std::string const debugName = strings::to_string(m_params.m_featureID.m_index) + "-" +
                                 strings::to_string(m_textIndex);
 
-  drape_ptr<dp::OverlayHandle> handle = m_needOverlay ?
-        make_unique_dp<dp::SquareHandle>(overlayId, m_params.m_anchor, m_point, pixelSize,
-                                         m_params.m_offset, GetOverlayPriority(), true /* isBound */,
-                                         debugName, true /* isBillboard */) : nullptr;
-  if (m_needOverlay && m_params.m_specialDisplacement == SpecialDisplacement::UserMark)
-    handle->SetUserMarkOverlay(true);
+  drape_ptr<dp::OverlayHandle> handle;
+  if (m_needOverlay)
+  {
+    if (!m_overlaySizes.empty())
+    {
+      handle = make_unique_dp<DynamicSquareHandle>(overlayId, m_params.m_anchor, m_point, m_overlaySizes,
+                                                   m_params.m_offset, GetOverlayPriority(), true /* isBound */,
+                                                   debugName, true /* isBillboard */);
+    }
+    else
+    {
+      handle = make_unique_dp<dp::SquareHandle>(overlayId, m_params.m_anchor, m_point, pixelSize,
+                                                m_params.m_offset, GetOverlayPriority(), true /* isBound */,
+                                                debugName, true /* isBillboard */);
+    }
 
+    if (m_params.m_specialDisplacement == SpecialDisplacement::UserMark)
+      handle->SetUserMarkOverlay(true);
+  }
   auto state = CreateGLState(gpu::COLORED_SYMBOL_PROGRAM, m_params.m_depthLayer);
   state.SetProgram3dIndex(gpu::COLORED_SYMBOL_BILLBOARD_PROGRAM);
   state.SetColorTexture(colorRegion.GetTexture());
diff --git a/drape_frontend/colored_symbol_shape.hpp b/drape_frontend/colored_symbol_shape.hpp
index 4a3a91b892..d501909c77 100644
--- a/drape_frontend/colored_symbol_shape.hpp
+++ b/drape_frontend/colored_symbol_shape.hpp
@@ -12,6 +12,10 @@ class ColoredSymbolShape : public MapShape
 public:
   ColoredSymbolShape(m2::PointD const & mercatorPt, ColoredSymbolViewParams const & params,
                      TileKey const & tileKey, uint32_t textIndex, bool needOverlay = true);
+
+  ColoredSymbolShape(m2::PointD const & mercatorPt, ColoredSymbolViewParams const & params,
+                     TileKey const & tileKey, uint32_t textIndex, std::vector<m2::PointF> const & overlaySizes);
+
   void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const override;
   MapShapeType GetType() const override { return MapShapeType::OverlayType; }
 
@@ -23,5 +27,6 @@ private:
   m2::PointI const m_tileCoords;
   uint32_t const m_textIndex;
   bool const m_needOverlay;
+  std::vector<m2::PointF> m_overlaySizes;
 };
 }  // namespace df
diff --git a/drape_frontend/drape_engine.cpp b/drape_frontend/drape_engine.cpp
index 6c7a2bf6f4..ea47367692 100644
--- a/drape_frontend/drape_engine.cpp
+++ b/drape_frontend/drape_engine.cpp
@@ -243,6 +243,7 @@ void DrapeEngine::UpdateUserMarksGroup(MarkGroupID groupId, UserMarksProvider *
       renderInfo->m_titleDecl = mark->GetTitleDecl();
       renderInfo->m_symbolNames = mark->GetSymbolNames();
       renderInfo->m_coloredSymbols = mark->GetColoredSymbols();
+      renderInfo->m_symbolSizes = mark->GetSymbolSizes();
       renderInfo->m_hasSymbolPriority = mark->HasSymbolPriority();
       renderInfo->m_hasTitlePriority = mark->HasTitlePriority();
       renderInfo->m_priority = mark->GetPriority();
diff --git a/drape_frontend/text_layout.cpp b/drape_frontend/text_layout.cpp
index 2cd9293f5e..cdd51d72df 100644
--- a/drape_frontend/text_layout.cpp
+++ b/drape_frontend/text_layout.cpp
@@ -25,6 +25,8 @@ public:
     , m_buffer(buffer)
   {}
 
+  void SetPen(glsl::vec2 const & penOffset) {}
+
   void operator() (dp::TextureManager::GlyphRegion const & glyph)
   {
     m2::RectF const & mask = glyph.GetTexRect();
@@ -41,22 +43,24 @@ protected:
   gpu::TTextStaticVertexBuffer & m_buffer;
 };
 
-template<typename TParentGenerator>
-class StraightTextGeometryGenerator : public TParentGenerator
+class StraightTextGeometryGenerator
 {
 public:
-  template<typename... TParentGeneratorParams>
   StraightTextGeometryGenerator(glsl::vec4 const & pivot,
                                 glsl::vec2 const & pixelOffset, float textRatio,
-                                gpu::TTextDynamicVertexBuffer & dynBuffer,
-                                TParentGeneratorParams & ... parentGeneratorParams)
-    : TParentGenerator(parentGeneratorParams...)
-    , m_pivot(pivot)
-    , m_penPosition(pixelOffset)
+                                gpu::TTextDynamicVertexBuffer & dynBuffer)
+    : m_pivot(pivot)
+    , m_pixelOffset(pixelOffset)
     , m_buffer(dynBuffer)
     , m_textRatio(textRatio)
   {}
 
+  void SetPen(glsl::vec2 const & penPosition)
+  {
+    m_penPosition = penPosition;
+    m_isFirstGlyph = true;
+  }
+
   void operator()(dp::TextureManager::GlyphRegion const & glyph)
   {
     if (!glyph.IsValid())
@@ -76,17 +80,16 @@ public:
     }
 
     using TDV = gpu::TextDynamicVertex;
-    m_buffer.emplace_back(TDV(m_pivot, m_penPosition + glsl::vec2(xOffset, bottomVector)));
-    m_buffer.emplace_back(TDV(m_pivot, m_penPosition + glsl::vec2(xOffset, upVector)));
-    m_buffer.emplace_back(TDV(m_pivot, m_penPosition + glsl::vec2(pixelSize.x + xOffset, bottomVector)));
-    m_buffer.emplace_back(TDV(m_pivot, m_penPosition + glsl::vec2(pixelSize.x + xOffset, upVector)));
+    m_buffer.emplace_back(TDV(m_pivot, m_pixelOffset + m_penPosition + glsl::vec2(xOffset, bottomVector)));
+    m_buffer.emplace_back(TDV(m_pivot, m_pixelOffset + m_penPosition + glsl::vec2(xOffset, upVector)));
+    m_buffer.emplace_back(TDV(m_pivot, m_pixelOffset + m_penPosition + glsl::vec2(pixelSize.x + xOffset, bottomVector)));
+    m_buffer.emplace_back(TDV(m_pivot, m_pixelOffset + m_penPosition + glsl::vec2(pixelSize.x + xOffset, upVector)));
     m_penPosition += glsl::vec2(glyph.GetAdvanceX() * m_textRatio, glyph.GetAdvanceY() * m_textRatio);
-
-    TParentGenerator::operator()(glyph);
   }
 
 private:
   glsl::vec4 const & m_pivot;
+  glsl::vec2 m_pixelOffset;
   glsl::vec2 m_penPosition;
   gpu::TTextDynamicVertexBuffer & m_buffer;
   float m_textRatio = 0.0f;
@@ -104,6 +107,8 @@ public:
     , m_buffer(buffer)
   {}
 
+  void SetPen(glsl::vec2 const & penOffset) {}
+
   void operator() (dp::TextureManager::GlyphRegion const & glyph)
   {
     using TOSV = gpu::TextOutlinedStaticVertex;
@@ -352,45 +357,57 @@ StraightTextLayout::StraightTextLayout(strings::UniString const & text, float fo
   CalculateOffsets(anchor, m_textSizeRatio, m_metrics, delimIndexes, m_offsets, m_pixelSize);
 }
 
-void StraightTextLayout::Cache(glm::vec4 const & pivot, glm::vec2 const & pixelOffset,
-                               dp::TextureManager::ColorRegion const & colorRegion,
-                               dp::TextureManager::ColorRegion const & outlineRegion,
-                               gpu::TTextOutlinedStaticVertexBuffer & staticBuffer,
-                               gpu::TTextDynamicVertexBuffer & dynamicBuffer) const
+void StraightTextLayout::AdjustTextOffset(m2::PointF const & symbolSize, dp::Anchor textAnchor, dp::Anchor symbolAnchor,
+                                          glsl::vec2 & offset) const
 {
-  size_t beginOffset = 0;
-  for (pair<size_t, glsl::vec2> const & node : m_offsets)
+  offset = m_baseOffset;
+
+  float const halfSymbolW = symbolSize.x / 2.0f;
+  float const halfSymbolH = symbolSize.y / 2.0f;
+
+  auto const adjustOffset = [&](dp::Anchor anchor)
   {
-    StraightTextGeometryGenerator<TextOutlinedGeometryGenerator> generator(
-          pivot, pixelOffset + node.second, m_textSizeRatio, dynamicBuffer,
-          colorRegion, outlineRegion, staticBuffer);
+    if (anchor & dp::Top)
+      offset.y += halfSymbolH;
+    else if (anchor & dp::Bottom)
+      offset.y -= halfSymbolH;
 
-    size_t const endOffset = node.first;
-    for (size_t index = beginOffset; index < endOffset && index < m_metrics.size(); ++index)
-      generator(m_metrics[index]);
+    if (anchor & dp::Left)
+      offset.x += halfSymbolW;
+    else if (anchor & dp::Right)
+      offset.x -= halfSymbolW;
+  };
 
-    beginOffset = endOffset;
-  }
+  adjustOffset(textAnchor);
+  adjustOffset(symbolAnchor);
 }
 
-void StraightTextLayout::Cache(glm::vec4 const & pivot, glm::vec2 const & pixelOffset,
-                               dp::TextureManager::ColorRegion const & color,
-                               gpu::TTextStaticVertexBuffer & staticBuffer,
-                               gpu::TTextDynamicVertexBuffer & dynamicBuffer) const
+void StraightTextLayout::CacheStaticGeometry(dp::TextureManager::ColorRegion const & colorRegion,
+                                             gpu::TTextStaticVertexBuffer & staticBuffer) const
 {
-  size_t beginOffset = 0;
-  for (pair<size_t, glsl::vec2> const & node : m_offsets)
-  {
-    StraightTextGeometryGenerator<TextGeometryGenerator> generator(
-          pivot, pixelOffset + node.second, m_textSizeRatio, dynamicBuffer,
-          color, staticBuffer);
+  TextGeometryGenerator staticGenerator(colorRegion, staticBuffer);
+  Cache(staticGenerator);
+}
+
+void StraightTextLayout::CacheStaticGeometry(dp::TextureManager::ColorRegion const & colorRegion,
+                                             dp::TextureManager::ColorRegion const & outlineRegion,
+                                             gpu::TTextOutlinedStaticVertexBuffer & staticBuffer) const
+{
+  TextOutlinedGeometryGenerator outlinedGenerator(colorRegion, outlineRegion, staticBuffer);
+  Cache(outlinedGenerator);
+}
 
-    size_t const endOffset = node.first;
-    for (size_t index = beginOffset; index < endOffset && index < m_metrics.size(); ++index)
-      generator(m_metrics[index]);
+void StraightTextLayout::SetBasePosition(glm::vec4 const & pivot, glm::vec2 const & baseOffset)
+{
+  m_pivot = pivot;
+  m_baseOffset = baseOffset;
+}
 
-    beginOffset = endOffset;
-  }
+void StraightTextLayout::CacheDynamicGeometry(glsl::vec2 const & pixelOffset,
+                                              gpu::TTextDynamicVertexBuffer & dynamicBuffer) const
+{
+  StraightTextGeometryGenerator generator(m_pivot, pixelOffset, m_textSizeRatio, dynamicBuffer);
+  Cache(generator);
 }
 
 PathTextLayout::PathTextLayout(m2::PointD const & tileCenter, strings::UniString const & text,
diff --git a/drape_frontend/text_layout.hpp b/drape_frontend/text_layout.hpp
index 5c46dd6837..8fb8f4c801 100644
--- a/drape_frontend/text_layout.hpp
+++ b/drape_frontend/text_layout.hpp
@@ -57,20 +57,37 @@ public:
                      ref_ptr<dp::TextureManager> textures,
                      dp::Anchor anchor);
 
-  void Cache(const glm::vec4 & pivot, glsl::vec2 const & pixelOffset,
-             dp::TextureManager::ColorRegion const & colorRegion,
-             dp::TextureManager::ColorRegion const & outlineRegion,
-             gpu::TTextOutlinedStaticVertexBuffer & staticBuffer,
-             gpu::TTextDynamicVertexBuffer & dynamicBuffer) const;
+  void CacheStaticGeometry(dp::TextureManager::ColorRegion const & colorRegion,
+                           gpu::TTextStaticVertexBuffer & staticBuffer) const;
+
+  void CacheStaticGeometry(dp::TextureManager::ColorRegion const & colorRegion,
+                           dp::TextureManager::ColorRegion const & outlineRegion,
+                           gpu::TTextOutlinedStaticVertexBuffer & staticBuffer) const;
 
-  void Cache(const glm::vec4 & pivot, glsl::vec2 const & pixelOffset,
-             dp::TextureManager::ColorRegion const & color,
-             gpu::TTextStaticVertexBuffer & staticBuffer,
-             gpu::TTextDynamicVertexBuffer & dynamicBuffer) const;
+  void SetBasePosition(glm::vec4 const & pivot, glm::vec2 const & baseOffset);
+  void CacheDynamicGeometry(glsl::vec2 const & pixelOffset, gpu::TTextDynamicVertexBuffer & dynamicBuffer) const;
 
   m2::PointF const & GetPixelSize() const { return m_pixelSize; }
 
+  void AdjustTextOffset(m2::PointF const & symbolSize, dp::Anchor textAnchor, dp::Anchor symbolAnchor,
+                        glsl::vec2 & offset) const;
 private:
+  template <typename TGenerator>
+  void Cache(TGenerator & generator) const
+  {
+    size_t beginOffset = 0;
+    for (pair<size_t, glsl::vec2> const & node : m_offsets)
+    {
+      size_t const endOffset = node.first;
+      generator.SetPen(node.second);
+      for (size_t index = beginOffset; index < endOffset && index < m_metrics.size(); ++index)
+        generator(m_metrics[index]);
+      beginOffset = endOffset;
+    }
+  }
+
+  glm::vec2 m_baseOffset;
+  glm::vec4 m_pivot;
   buffer_vector<pair<size_t, glsl::vec2>, 2> m_offsets;
   m2::PointF m_pixelSize;
 };
diff --git a/drape_frontend/text_shape.cpp b/drape_frontend/text_shape.cpp
index b71cb633d8..cb11c328d9 100644
--- a/drape_frontend/text_shape.cpp
+++ b/drape_frontend/text_shape.cpp
@@ -3,6 +3,7 @@
 #include "drape_frontend/shader_def.hpp"
 #include "drape_frontend/text_handle.hpp"
 #include "drape_frontend/text_layout.hpp"
+#include "drape_frontend/visual_params.hpp"
 
 #include "drape/utils/vertex_decl.hpp"
 #include "drape/attribute_provider.hpp"
@@ -36,6 +37,42 @@ public:
     , m_isOptional(isOptional)
   {}
 
+  void SetDynamicSymbolSizes(StraightTextLayout const &layout,
+                             std::vector<m2::PointF> const &symbolSizes,
+                             dp::Anchor symbolAnchor)
+  {
+    m_layout = make_unique_dp<StraightTextLayout>(layout);
+    m_symbolSizes = symbolSizes;
+    m_symbolAnchor = symbolAnchor;
+  }
+
+  void GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator> mutator) const override
+  {
+    SetForceUpdateNormals(IsVisible() && m_layout != nullptr);
+    TextHandle::GetAttributeMutation(mutator);
+  }
+
+  bool Update(ScreenBase const & screen) override
+  {
+    if (!TBase::Update(screen))
+      return false;
+
+    if (m_layout != nullptr)
+    {
+      double zoom = 0.0;
+      int index = 0;
+      float lerpCoef = 0.0f;
+      ExtractZoomFactors(screen, zoom, index, lerpCoef);
+      m2::PointF symbolSize = InterpolateByZoomLevels(index, lerpCoef, m_symbolSizes);
+      glsl::vec2 offset;
+      m_layout->AdjustTextOffset(symbolSize, m_anchor, m_symbolAnchor, offset);
+      m_buffer.clear();
+      m_layout->CacheDynamicGeometry(offset, m_buffer);
+      m_offset = glsl::ToPoint(offset);
+    }
+    return true;
+  }
+
   m2::PointD GetPivot(ScreenBase const & screen, bool perspective) const override
   {
     m2::PointD pivot = TBase::GetPivot(screen, false);
@@ -106,6 +143,9 @@ private:
   m2::PointF m_offset;
   m2::PointF m_size;
   bool m_isOptional;
+  drape_ptr<StraightTextLayout> m_layout;
+  std::vector<m2::PointF> m_symbolSizes;
+  dp::Anchor m_symbolAnchor;
 };
 }  // namespace
 
@@ -116,116 +156,111 @@ TextShape::TextShape(m2::PointD const & basePoint, TextViewParams const & params
   : m_basePoint(basePoint)
   , m_params(params)
   , m_tileCoords(tileKey.GetTileCoords())
-  , m_symbolSize(symbolSize)
   , m_symbolAnchor(symbolAnchor)
   , m_textIndex(textIndex)
-{}
-
-void TextShape::Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const
 {
-  auto const & titleDecl = m_params.m_titleDecl;
-  ASSERT(!titleDecl.m_primaryText.empty(), ());
-  StraightTextLayout primaryLayout(strings::MakeUniString(titleDecl.m_primaryText),
-                                   titleDecl.m_primaryTextFont.m_size,
-                                   titleDecl.m_primaryTextFont.m_isSdf,
-                                   textures,
-                                   titleDecl.m_anchor);
-
-  if (m_params.m_limitedText && primaryLayout.GetPixelSize().y >= m_params.m_limits.y)
-  {
-    float const newFontSize = titleDecl.m_primaryTextFont.m_size * m_params.m_limits.y / primaryLayout.GetPixelSize().y;
-    primaryLayout = StraightTextLayout(strings::MakeUniString(titleDecl.m_primaryText), newFontSize,
-                                       titleDecl.m_primaryTextFont.m_isSdf, textures, titleDecl.m_anchor);
-  }
+  m_symbolSizes.push_back(symbolSize);
+}
 
-  drape_ptr<StraightTextLayout> secondaryLayout;
-  if (!titleDecl.m_secondaryText.empty())
-  {
-    secondaryLayout = make_unique_dp<StraightTextLayout>(strings::MakeUniString(titleDecl.m_secondaryText),
-                                                         titleDecl.m_secondaryTextFont.m_size,
-                                                         titleDecl.m_secondaryTextFont.m_isSdf,
-                                                         textures,
-                                                         titleDecl.m_anchor);
-  }
+TextShape::TextShape(m2::PointD const & basePoint, TextViewParams const & params,
+                     TileKey const & tileKey, std::vector<m2::PointF> const & symbolSizes,
+                     dp::Anchor symbolAnchor, uint32_t textIndex)
+  : m_basePoint(basePoint)
+  , m_params(params)
+  , m_tileCoords(tileKey.GetTileCoords())
+  , m_symbolSizes(symbolSizes)
+  , m_symbolAnchor(symbolAnchor)
+  , m_textIndex(textIndex)
+{
+  ASSERT_GREATER(m_symbolSizes.size(), 0, ());
+}
 
-  glsl::vec2 primaryOffset(0.0f, 0.0f);
-  glsl::vec2 secondaryOffset(0.0f, 0.0f);
+void CalculateTextOffsets(dp::TitleDecl const titleDecl, m2::PointF const & primaryTextSize,
+                          m2::PointF const & secondaryTextSize, glsl::vec2 & primaryResultOffset,
+                          glsl::vec2 & secondaryResultOffset)
+{
+  primaryResultOffset = glsl::vec2(0.0f, 0.0f);
+  secondaryResultOffset = glsl::vec2(0.0f, 0.0f);
 
-  float const halfSymbolW = m_symbolSize.x / 2.0f;
-  float const halfSymbolH = m_symbolSize.y / 2.0f;
+  bool const hasSecondary = !titleDecl.m_secondaryText.empty();
 
   if (titleDecl.m_anchor & dp::Top)
   {
     // In the case when the anchor is dp::Top the value of primary offset y > 0,
     // the text shape is below the POI.
-    primaryOffset.y = titleDecl.m_primaryOffset.y + halfSymbolH;
-    if (secondaryLayout != nullptr)
-    {
-      secondaryOffset.y = titleDecl.m_primaryOffset.y + primaryLayout.GetPixelSize().y +
-          titleDecl.m_secondaryOffset.y + halfSymbolH;
-    }
+    primaryResultOffset.y = titleDecl.m_primaryOffset.y;
+    if (hasSecondary)
+      secondaryResultOffset.y = titleDecl.m_primaryOffset.y + primaryTextSize.y + titleDecl.m_secondaryOffset.y;
   }
   else if (titleDecl.m_anchor & dp::Bottom)
   {
     // In the case when the anchor is dp::Bottom the value of primary offset y < 0,
     // the text shape is above the POI.
-    primaryOffset.y = titleDecl.m_primaryOffset.y - halfSymbolH;
-    if (secondaryLayout != nullptr)
+    primaryResultOffset.y = titleDecl.m_primaryOffset.y;
+    if (hasSecondary)
     {
-      primaryOffset.y -= secondaryLayout->GetPixelSize().y + titleDecl.m_secondaryOffset.y;
-      secondaryOffset.y = titleDecl.m_primaryOffset.y - halfSymbolH;
+      primaryResultOffset.y -= secondaryTextSize.y + titleDecl.m_secondaryOffset.y;
+      secondaryResultOffset.y = titleDecl.m_primaryOffset.y;
     }
   }
-  else if (secondaryLayout != nullptr)
+  else if (hasSecondary)
   {
     // In the case when the anchor is dp::Center there isn't primary offset y.
-    primaryOffset.y = -(primaryLayout.GetPixelSize().y + titleDecl.m_secondaryOffset.y) / 2.0f;
-    secondaryOffset.y = (secondaryLayout->GetPixelSize().y + titleDecl.m_secondaryOffset.y) / 2.0f;
+    primaryResultOffset.y = -(primaryTextSize.y + titleDecl.m_secondaryOffset.y) / 2.0f;
+    secondaryResultOffset.y = (secondaryTextSize.y + titleDecl.m_secondaryOffset.y) / 2.0f;
   }
 
   if (titleDecl.m_anchor & dp::Left)
   {
     // In the case when the anchor is dp::Left the value of primary offset x > 0,
     // the text shape is on the right from the POI.
-    primaryOffset.x = titleDecl.m_primaryOffset.x + halfSymbolW;
-    if (secondaryLayout != nullptr)
-      secondaryOffset.x = primaryOffset.x;
+    primaryResultOffset.x = titleDecl.m_primaryOffset.x;
+    if (hasSecondary)
+      secondaryResultOffset.x = primaryResultOffset.x;
   }
   else if (titleDecl.m_anchor & dp::Right)
   {
     // In the case when the anchor is dp::Right the value of primary offset x < 0,
     // the text shape is on the left from the POI.
-    primaryOffset.x = titleDecl.m_primaryOffset.x - halfSymbolW;
-    if (secondaryLayout != nullptr)
-      secondaryOffset.x = primaryOffset.x;
+    primaryResultOffset.x = titleDecl.m_primaryOffset.x;
+    if (hasSecondary)
+      secondaryResultOffset.x = primaryResultOffset.x;
   }
+}
 
-  if (m_symbolAnchor & dp::Top)
-  {
-    primaryOffset.y += halfSymbolH;
-    if (secondaryLayout != nullptr)
-      secondaryOffset.y += halfSymbolH;
-  }
-  else if (m_symbolAnchor & dp::Bottom)
-  {
-    primaryOffset.y -= halfSymbolH;
-    if (secondaryLayout != nullptr)
-      secondaryOffset.y -= halfSymbolH;
-  }
+void TextShape::Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const
+{
+  auto const & titleDecl = m_params.m_titleDecl;
+  ASSERT(!titleDecl.m_primaryText.empty(), ());
+  StraightTextLayout primaryLayout(strings::MakeUniString(titleDecl.m_primaryText),
+                                   titleDecl.m_primaryTextFont.m_size,
+                                   titleDecl.m_primaryTextFont.m_isSdf,
+                                   textures,
+                                   titleDecl.m_anchor);
 
-  if (m_symbolAnchor & dp::Left)
+  if (m_params.m_limitedText && primaryLayout.GetPixelSize().y >= m_params.m_limits.y)
   {
-    primaryOffset.x += halfSymbolW;
-    if (secondaryLayout != nullptr)
-      secondaryOffset.x += halfSymbolW;
+    float const newFontSize = titleDecl.m_primaryTextFont.m_size * m_params.m_limits.y / primaryLayout.GetPixelSize().y;
+    primaryLayout = StraightTextLayout(strings::MakeUniString(titleDecl.m_primaryText), newFontSize,
+                                       titleDecl.m_primaryTextFont.m_isSdf, textures, titleDecl.m_anchor);
   }
-  else if (m_symbolAnchor & dp::Right)
+
+  drape_ptr<StraightTextLayout> secondaryLayout;
+  if (!titleDecl.m_secondaryText.empty())
   {
-    primaryOffset.x -= halfSymbolW;
-    if (secondaryLayout != nullptr)
-      secondaryOffset.x -= halfSymbolW;
+    secondaryLayout = make_unique_dp<StraightTextLayout>(strings::MakeUniString(titleDecl.m_secondaryText),
+                                                         titleDecl.m_secondaryTextFont.m_size,
+                                                         titleDecl.m_secondaryTextFont.m_isSdf,
+                                                         textures,
+                                                         titleDecl.m_anchor);
   }
 
+  glsl::vec2 primaryOffset;
+  glsl::vec2 secondaryOffset;
+  CalculateTextOffsets(titleDecl, primaryLayout.GetPixelSize(),
+                       secondaryLayout != nullptr ? secondaryLayout->GetPixelSize() : m2::PointF(0.0f, 0.0f),
+                       primaryOffset, secondaryOffset);
+
   if (primaryLayout.GetGlyphCount() > 0)
   {
     DrawSubString(primaryLayout, titleDecl.m_primaryTextFont, primaryOffset, batcher,
@@ -239,11 +274,14 @@ void TextShape::Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> t
   }
 }
 
-void TextShape::DrawSubString(StraightTextLayout const & layout, dp::FontDecl const & font,
+void TextShape::DrawSubString(StraightTextLayout & layout, dp::FontDecl const & font,
                               glm::vec2 const & baseOffset, ref_ptr<dp::Batcher> batcher,
                               ref_ptr<dp::TextureManager> textures,
                               bool isPrimary, bool isOptional) const
 {
+  glsl::vec2 const pt = glsl::ToVec2(ConvertToLocal(m_basePoint, m_params.m_tileCenter, kShapeCoordScalar));
+  layout.SetBasePosition(glsl::vec4(pt, m_params.m_depth, -m_params.m_posZ), baseOffset);
+
   dp::Color outlineColor = isPrimary ? m_params.m_titleDecl.m_primaryTextFont.m_outlineColor
                                      : m_params.m_titleDecl.m_secondaryTextFont.m_outlineColor;
 
@@ -264,9 +302,11 @@ void TextShape::DrawSubStringPlain(StraightTextLayout const & layout, dp::FontDe
   textures->GetColorRegion(font.m_color, color);
   textures->GetColorRegion(font.m_outlineColor, outline);
 
-  glsl::vec2 const pt = glsl::ToVec2(ConvertToLocal(m_basePoint, m_params.m_tileCenter, kShapeCoordScalar));
-  layout.Cache(glsl::vec4(pt, m_params.m_depth, -m_params.m_posZ),
-               baseOffset, color, staticBuffer, dynamicBuffer);
+  glm::vec2 finalOffset = baseOffset;
+  layout.AdjustTextOffset(m_symbolSizes.front(), m_params.m_titleDecl.m_anchor, m_symbolAnchor, finalOffset);
+  layout.CacheDynamicGeometry(finalOffset, dynamicBuffer);
+
+  layout.CacheStaticGeometry(color, staticBuffer);
 
   bool const isNonSdfText = layout.GetFixedHeight() > 0;
   auto state = CreateGLState(isNonSdfText ? gpu::TEXT_FIXED_PROGRAM : gpu::TEXT_PROGRAM, m_params.m_depthLayer);
@@ -284,18 +324,20 @@ void TextShape::DrawSubStringPlain(StraightTextLayout const & layout, dp::FontDe
   m2::PointF const & pixelSize = layout.GetPixelSize();
 
   auto overlayId = dp::OverlayID(m_params.m_featureID, m_tileCoords, m_textIndex);
-  drape_ptr<dp::OverlayHandle> handle = make_unique_dp<StraightTextHandle>(overlayId,
-                                                                           layout.GetText(),
-                                                                           m_params.m_titleDecl.m_anchor,
-                                                                           glsl::ToVec2(m_basePoint),
-                                                                           glsl::vec2(pixelSize.x, pixelSize.y),
-                                                                           baseOffset,
-                                                                           GetOverlayPriority(),
-                                                                           layout.GetFixedHeight(),
-                                                                           textures,
-                                                                           isOptional,
-                                                                           std::move(dynamicBuffer),
-                                                                           true);
+  drape_ptr<StraightTextHandle> handle = make_unique_dp<StraightTextHandle>(overlayId,
+                                                                            layout.GetText(),
+                                                                            m_params.m_titleDecl.m_anchor,
+                                                                            glsl::ToVec2(m_basePoint),
+                                                                            glsl::vec2(pixelSize.x, pixelSize.y),
+                                                                            finalOffset,
+                                                                            GetOverlayPriority(),
+                                                                            layout.GetFixedHeight(),
+                                                                            textures,
+                                                                            isOptional,
+                                                                            std::move(dynamicBuffer),
+                                                                            true);
+  if (m_symbolSizes.size() > 1)
+    handle->SetDynamicSymbolSizes(layout, m_symbolSizes, m_symbolAnchor);
   handle->SetPivotZ(m_params.m_posZ);
 
   ASSERT_LESS(m_params.m_startOverlayRank + 1, dp::OverlayRanksCount, ());
@@ -322,9 +364,11 @@ void TextShape::DrawSubStringOutlined(StraightTextLayout const & layout, dp::Fon
   textures->GetColorRegion(font.m_color, color);
   textures->GetColorRegion(font.m_outlineColor, outline);
 
-  glsl::vec2 const pt = glsl::ToVec2(ConvertToLocal(m_basePoint, m_params.m_tileCenter, kShapeCoordScalar));
-  layout.Cache(glsl::vec4(pt, m_params.m_depth, -m_params.m_posZ),
-               baseOffset, color, outline, staticBuffer, dynamicBuffer);
+  glm::vec2 finalOffset = baseOffset;
+  layout.AdjustTextOffset(m_symbolSizes.front(), m_params.m_titleDecl.m_anchor, m_symbolAnchor, finalOffset);
+
+  layout.CacheDynamicGeometry(finalOffset, dynamicBuffer);
+  layout.CacheStaticGeometry(color, outline, staticBuffer);
 
   auto state = CreateGLState(gpu::TEXT_OUTLINED_PROGRAM, m_params.m_depthLayer);
   state.SetProgram3dIndex(gpu::TEXT_OUTLINED_BILLBOARD_PROGRAM);
@@ -337,18 +381,20 @@ void TextShape::DrawSubStringOutlined(StraightTextLayout const & layout, dp::Fon
   m2::PointF const & pixelSize = layout.GetPixelSize();
 
   auto overlayId = dp::OverlayID(m_params.m_featureID, m_tileCoords, m_textIndex);
-  drape_ptr<dp::OverlayHandle> handle = make_unique_dp<StraightTextHandle>(overlayId,
-                                                                           layout.GetText(),
-                                                                           m_params.m_titleDecl.m_anchor,
-                                                                           glsl::ToVec2(m_basePoint),
-                                                                           glsl::vec2(pixelSize.x, pixelSize.y),
-                                                                           baseOffset,
-                                                                           GetOverlayPriority(),
-                                                                           layout.GetFixedHeight(),
-                                                                           textures,
-                                                                           isOptional,
-                                                                           std::move(dynamicBuffer),
-                                                                           true);
+  drape_ptr<StraightTextHandle> handle = make_unique_dp<StraightTextHandle>(overlayId,
+                                                                            layout.GetText(),
+                                                                            m_params.m_titleDecl.m_anchor,
+                                                                            glsl::ToVec2(m_basePoint),
+                                                                            glsl::vec2(pixelSize.x, pixelSize.y),
+                                                                            finalOffset,
+                                                                            GetOverlayPriority(),
+                                                                            layout.GetFixedHeight(),
+                                                                            textures,
+                                                                            isOptional,
+                                                                            std::move(dynamicBuffer),
+                                                                            true);
+  if (m_symbolSizes.size() > 1)
+    handle->SetDynamicSymbolSizes(layout, m_symbolSizes, m_symbolAnchor);
   handle->SetPivotZ(m_params.m_posZ);
 
   ASSERT_LESS(m_params.m_startOverlayRank + 1, dp::OverlayRanksCount, ());
diff --git a/drape_frontend/text_shape.hpp b/drape_frontend/text_shape.hpp
index 89c4b5da54..f6244c9cab 100644
--- a/drape_frontend/text_shape.hpp
+++ b/drape_frontend/text_shape.hpp
@@ -8,6 +8,8 @@
 
 #include "geometry/point2d.hpp"
 
+#include <vector>
+
 namespace df
 {
 class StraightTextLayout;
@@ -19,6 +21,10 @@ public:
             TileKey const & tileKey, m2::PointF const & symbolSize,
             dp::Anchor symbolAnchor, uint32_t textIndex);
 
+  TextShape(m2::PointD const & basePoint, TextViewParams const & params,
+            TileKey const & tileKey, std::vector<m2::PointF> const & symbolSizes,
+            dp::Anchor symbolAnchor, uint32_t textIndex);
+
   void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const override;
   MapShapeType GetType() const override { return MapShapeType::OverlayType; }
 
@@ -26,7 +32,7 @@ public:
   void DisableDisplacing() { m_disableDisplacing = true; }
 
 private:
-  void DrawSubString(StraightTextLayout const & layout, dp::FontDecl const & font,
+  void DrawSubString(StraightTextLayout & layout, dp::FontDecl const & font,
                      glsl::vec2 const & baseOffset, ref_ptr<dp::Batcher> batcher,
                      ref_ptr<dp::TextureManager> textures, bool isPrimary, bool isOptional) const;
 
@@ -42,7 +48,7 @@ private:
   m2::PointD m_basePoint;
   TextViewParams m_params;
   m2::PointI m_tileCoords;
-  m2::PointF m_symbolSize;
+  std::vector<m2::PointF> m_symbolSizes;
   dp::Anchor m_symbolAnchor;
   uint32_t m_textIndex;
 
diff --git a/drape_frontend/user_mark_shapes.cpp b/drape_frontend/user_mark_shapes.cpp
index 5911c28e96..fe01d6d9d5 100644
--- a/drape_frontend/user_mark_shapes.cpp
+++ b/drape_frontend/user_mark_shapes.cpp
@@ -153,8 +153,16 @@ void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> texture
             params.m_minVisibleScale = renderInfo.m_minZoom;
             params.m_specialDisplacement = SpecialDisplacement::UserMark;
             params.m_specialPriority = renderInfo.m_priority;
-            ColoredSymbolShape(renderInfo.m_pivot, params, tileKey,
-                               kStartUserMarkOverlayIndex + renderInfo.m_index).Draw(&batcher, textures);
+            if (renderInfo.m_symbolSizes != nullptr)
+            {
+              ColoredSymbolShape(renderInfo.m_pivot, params, tileKey, kStartUserMarkOverlayIndex + renderInfo.m_index,
+                                 *renderInfo.m_symbolSizes.get()).Draw(&batcher, textures);
+            }
+            else
+            {
+              ColoredSymbolShape(renderInfo.m_pivot, params, tileKey,
+                                 kStartUserMarkOverlayIndex + renderInfo.m_index).Draw(&batcher, textures);
+            }
             break;
           }
         }
@@ -246,8 +254,16 @@ void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> texture
           ASSERT_LESS(params.m_startOverlayRank, dp::OverlayRanksCount, ());
         }
 
-        TextShape(renderInfo.m_pivot, params, tileKey,
-                  symbolSize, renderInfo.m_anchor, overlayIndex).Draw(&batcher, textures);
+        if (renderInfo.m_symbolSizes != nullptr)
+        {
+          TextShape(renderInfo.m_pivot, params, tileKey,
+                    *renderInfo.m_symbolSizes.get(), renderInfo.m_anchor, overlayIndex).Draw(&batcher, textures);
+        }
+        else
+        {
+          TextShape(renderInfo.m_pivot, params, tileKey,
+                    symbolSize, renderInfo.m_anchor, overlayIndex).Draw(&batcher, textures);
+        }
       }
     }
 
diff --git a/drape_frontend/user_mark_shapes.hpp b/drape_frontend/user_mark_shapes.hpp
index 0c2fe0fba2..99ebc73e80 100644
--- a/drape_frontend/user_mark_shapes.hpp
+++ b/drape_frontend/user_mark_shapes.hpp
@@ -23,6 +23,7 @@ struct UserMarkRenderParams
   drape_ptr<UserPointMark::ColoredSymbolZoomInfo> m_coloredSymbols;
   drape_ptr<UserPointMark::SymbolNameZoomInfo> m_symbolNames;
   drape_ptr<UserPointMark::TitlesInfo> m_titleDecl;
+  drape_ptr<UserPointMark::SymbolSizes> m_symbolSizes;
   bool m_hasSymbolPriority = false;
   bool m_hasTitlePriority = false;
   uint16_t m_priority = 0;
diff --git a/drape_frontend/user_marks_provider.hpp b/drape_frontend/user_marks_provider.hpp
index efd2e76d34..a31329c260 100644
--- a/drape_frontend/user_marks_provider.hpp
+++ b/drape_frontend/user_marks_provider.hpp
@@ -42,6 +42,7 @@ public:
   using ColoredSymbolZoomInfo = std::map<int, df::ColoredSymbolViewParams>;
   using SymbolNameZoomInfo = std::map<int, std::string>;
   using TitlesInfo = std::vector<dp::TitleDecl>;
+  using SymbolSizes = std::vector<m2::PointF>;
 
   UserPointMark();
   virtual ~UserPointMark() {}
@@ -60,6 +61,7 @@ public:
   virtual drape_ptr<TitlesInfo> GetTitleDecl() const = 0;
   virtual drape_ptr<SymbolNameZoomInfo> GetSymbolNames() const = 0;
   virtual drape_ptr<ColoredSymbolZoomInfo> GetColoredSymbols() const = 0;
+  virtual drape_ptr<SymbolSizes> GetSymbolSizes() const = 0;
   virtual uint16_t GetPriority() const = 0;
   virtual uint32_t GetIndex() const = 0;
   virtual bool HasSymbolPriority() const = 0;
diff --git a/drape_frontend/visual_params.cpp b/drape_frontend/visual_params.cpp
index 2ba044fa8f..e7e44c0068 100644
--- a/drape_frontend/visual_params.cpp
+++ b/drape_frontend/visual_params.cpp
@@ -313,6 +313,15 @@ float InterpolateByZoomLevels(int index, float lerpCoef, std::vector<float> cons
   return values[scales::UPPER_STYLE_SCALE];
 }
 
+m2::PointF InterpolateByZoomLevels(int index, float lerpCoef, std::vector<m2::PointF> const & values)
+{
+  ASSERT_GREATER_OR_EQUAL(index, 0, ());
+  ASSERT_GREATER(values.size(), scales::UPPER_STYLE_SCALE, ());
+  if (index < scales::UPPER_STYLE_SCALE)
+    return values[index] + (values[index + 1] - values[index]) * lerpCoef;
+  return values[scales::UPPER_STYLE_SCALE];
+}
+
 double GetNormalizedZoomLevel(double scale, int minZoom)
 {
   double const kMaxZoom = scales::GetUpperStyleScale() + 1.0;
diff --git a/drape_frontend/visual_params.hpp b/drape_frontend/visual_params.hpp
index eb32f284ee..034945745f 100644
--- a/drape_frontend/visual_params.hpp
+++ b/drape_frontend/visual_params.hpp
@@ -87,6 +87,7 @@ uint32_t CalculateTileSize(uint32_t screenWidth, uint32_t screenHeight);
 double GetZoomLevel(double scale);
 void ExtractZoomFactors(ScreenBase const & s, double & zoom, int & index, float & lerpCoef);
 float InterpolateByZoomLevels(int index, float lerpCoef, std::vector<float> const & values);
+m2::PointF InterpolateByZoomLevels(int index, float lerpCoef, std::vector<m2::PointF> const & values);
 double GetNormalizedZoomLevel(double scale, int minZoom = 1);
 double GetScale(double zoomLevel);
 
diff --git a/map/routing_mark.cpp b/map/routing_mark.cpp
index 5023ddcf84..e2ec4f0426 100644
--- a/map/routing_mark.cpp
+++ b/map/routing_mark.cpp
@@ -445,6 +445,18 @@ drape_ptr<df::UserPointMark::ColoredSymbolZoomInfo> TransitMark::GetColoredSymbo
   return make_unique_dp<ColoredSymbolZoomInfo>(m_coloredSymbols);
 }
 
+void TransitMark::SetSymbolSizes(SymbolSizes const & symbolSizes)
+{
+  m_symbolSizes = symbolSizes;
+}
+
+drape_ptr<df::UserPointMark::SymbolSizes> TransitMark::GetSymbolSizes() const
+{
+  if (m_symbolSizes.empty())
+    return nullptr;
+  return make_unique_dp<SymbolSizes>(m_symbolSizes);
+}
+
 drape_ptr<df::UserPointMark::SymbolNameZoomInfo> TransitMark::GetSymbolNames() const
 {
   if (m_symbolNames.empty())
diff --git a/map/routing_mark.hpp b/map/routing_mark.hpp
index b666a3f70b..ee6d028560 100644
--- a/map/routing_mark.hpp
+++ b/map/routing_mark.hpp
@@ -135,6 +135,9 @@ public:
   void SetSymbolNames(SymbolNameZoomInfo const & symbolNames);
   drape_ptr<SymbolNameZoomInfo> GetSymbolNames() const override;
 
+  void SetSymbolSizes(SymbolSizes const & symbolSizes);
+  drape_ptr<SymbolSizes> GetSymbolSizes() const override;
+
   void AddTitle(dp::TitleDecl const & titleDecl);
   drape_ptr<TitlesInfo> GetTitleDecl() const override;
 
@@ -149,4 +152,5 @@ private:
   TitlesInfo m_titles;
   SymbolNameZoomInfo m_symbolNames;
   ColoredSymbolZoomInfo m_coloredSymbols;
+  SymbolSizes m_symbolSizes;
 };
\ No newline at end of file
diff --git a/map/transit/transit_display.cpp b/map/transit/transit_display.cpp
index 45f5452d19..262fec980e 100644
--- a/map/transit/transit_display.cpp
+++ b/map/transit/transit_display.cpp
@@ -50,13 +50,14 @@ uint32_t ColorToARGB(df::ColorConstant const & colorConstant)
   return color.GetAlpha() << 24 | color.GetRed() << 16 | color.GetGreen() << 8 | color.GetBlue();
 }
 
-vector<m2::PointF> GetTransitMarkerSizes(float markerScale)
+vector<m2::PointF> GetTransitMarkerSizes(float markerScale, float maxRouteWidth)
 {
+  auto const vs = static_cast<float>(df::VisualParams::Instance().GetVisualScale());
   vector<m2::PointF> markerSizes;
   markerSizes.reserve(df::kRouteHalfWidthInPixelTransit.size());
   for (auto const halfWidth : df::kRouteHalfWidthInPixelTransit)
   {
-    float const d = 2 * halfWidth * markerScale;
+    float const d = 2.0f * std::min(halfWidth * vs, maxRouteWidth * 0.5f) * markerScale;
     markerSizes.push_back(m2::PointF(d, d));
   }
   return markerSizes;
@@ -458,13 +459,12 @@ void TransitRouteDisplay::CollectTransitDisplayInfo(vector<RouteSegment> const &
 
 void TransitRouteDisplay::CreateTransitMarks(std::vector<TransitMarkInfo> const & transitMarks)
 {
-  static vector<m2::PointF> const kTransferMarkerSizes = GetTransitMarkerSizes(kTransferMarkerScale);
-  static vector<m2::PointF> const kStopMarkerSizes = GetTransitMarkerSizes(kStopMarkerScale);
+  static vector<m2::PointF> const kTransferMarkerSizes = GetTransitMarkerSizes(kTransferMarkerScale, m_maxSubrouteWidth);
+  static vector<m2::PointF> const kStopMarkerSizes = GetTransitMarkerSizes(kStopMarkerScale, m_maxSubrouteWidth);
 
   auto & marksController = m_bmManager->GetUserMarksController(UserMark::Type::TRANSIT);
   uint32_t nextIndex = static_cast<uint32_t>(marksController.GetUserMarkCount());
 
-  auto const vs = df::VisualParams::Instance().GetVisualScale();
   for (size_t i = 0; i < transitMarks.size(); ++i)
   {
     auto const & mark = transitMarks[i];
@@ -519,11 +519,12 @@ void TransitRouteDisplay::CreateTransitMarks(std::vector<TransitMarkInfo> const
         auto const zoomLevel = sizeIndex + 1;
         auto const & sz = kTransferMarkerSizes[sizeIndex];
         df::ColoredSymbolViewParams params;
-        params.m_radiusInPixels = static_cast<float>(max(sz.x, sz.y) * vs / 2.0);
+        params.m_radiusInPixels = max(sz.x, sz.y) * 0.5f;
         params.m_color = dp::Color::Transparent();
         if (coloredSymbol.empty() || coloredSymbol.rbegin()->second.m_radiusInPixels != params.m_radiusInPixels)
           coloredSymbol.insert(make_pair(zoomLevel, params));
       }
+      transitMark->SetSymbolSizes(kTransferMarkerSizes);
       transitMark->SetColoredSymbols(coloredSymbol);
       transitMark->SetPriority(UserMark::Priority::TransitTransfer);
     }
@@ -552,15 +553,15 @@ void TransitRouteDisplay::CreateTransitMarks(std::vector<TransitMarkInfo> const
         params.m_color = df::GetColorConstant(mark.m_color);
 
         auto sz = m_symbolSizes.at(symbolNames[kSmallIconZoom]);
-        params.m_radiusInPixels = static_cast<float>(max(sz.x, sz.y) * kGateBgScale / 2.0);
+        params.m_radiusInPixels = max(sz.x, sz.y) * kGateBgScale * 0.5f;
         coloredSymbol[kSmallIconZoom] = params;
 
         sz = m_symbolSizes.at(symbolNames[kMediumIconZoom]);
-        params.m_radiusInPixels = static_cast<float>(max(sz.x, sz.y) * kGateBgScale / 2.0);
+        params.m_radiusInPixels = max(sz.x, sz.y) * kGateBgScale * 0.5f;
         coloredSymbol[kMediumIconZoom] = params;
 
         sz = m_symbolSizes.at(symbolNames[kLargeIconZoom]);
-        params.m_radiusInPixels = static_cast<float>(max(sz.x, sz.y) * kGateBgScale / 2.0);
+        params.m_radiusInPixels = max(sz.x, sz.y) * kGateBgScale * 0.5f;
         coloredSymbol[kLargeIconZoom] = params;
 
         transitMark->SetColoredSymbols(coloredSymbol);
@@ -574,11 +575,12 @@ void TransitRouteDisplay::CreateTransitMarks(std::vector<TransitMarkInfo> const
           auto const zoomLevel = sizeIndex + 1;
           auto const & sz = kStopMarkerSizes[sizeIndex];
           df::ColoredSymbolViewParams params;
-          params.m_radiusInPixels = static_cast<float>(max(sz.x, sz.y) * vs / 2.0);
+          params.m_radiusInPixels = max(sz.x, sz.y) * 0.5f;
           params.m_color = dp::Color::Transparent();
           if (coloredSymbol.empty() || coloredSymbol.rbegin()->second.m_radiusInPixels != params.m_radiusInPixels)
             coloredSymbol.insert(make_pair(zoomLevel, params));
         }
+        transitMark->SetSymbolSizes(kStopMarkerSizes);
         transitMark->SetColoredSymbols(coloredSymbol);
         transitMark->SetPriority(UserMark::Priority::TransitStop);
         transitMark->SetMinTitleZoom(kMinStopTitleZoom);
diff --git a/map/user_mark.hpp b/map/user_mark.hpp
index 07566130e5..ba247bd821 100644
--- a/map/user_mark.hpp
+++ b/map/user_mark.hpp
@@ -52,6 +52,7 @@ public:
   df::RenderState::DepthLayer GetDepthLayer() const override;
   drape_ptr<TitlesInfo> GetTitleDecl() const override { return nullptr; }
   drape_ptr<ColoredSymbolZoomInfo> GetColoredSymbols() const override { return nullptr; }
+  drape_ptr<SymbolSizes> GetSymbolSizes() const override { return nullptr; }
   uint16_t GetPriority() const override { return static_cast<uint16_t >(Priority::Default); }
   uint32_t GetIndex() const override { return 0; }
   bool HasSymbolPriority() const override { return false; }