[drape] text shapes refactoring

11 files changed, 148 insertions, 163 deletions

diff --git a/drape_frontend/apply_feature_functors.cpp b/drape_frontend/apply_feature_functors.cpp
index 4f2dbe8b32..4ddac68089 100644
--- a/drape_frontend/apply_feature_functors.cpp
+++ b/drape_frontend/apply_feature_functors.cpp
@@ -279,11 +279,9 @@ void ApplyAreaFeature::ProcessRule(Stylist::rule_wrapper_t const & rule)
 
 ApplyLineFeature::ApplyLineFeature(EngineContext & context, TileKey tileKey,
                                    FeatureID const & id, CaptionDescription const & captions,
-                                   double currentScaleGtoP,
-                                   double nextScaleGtoP)
+                                   double currentScaleGtoP)
   : TBase(context, tileKey, id, captions)
   , m_currentScaleGtoP(currentScaleGtoP)
-  , m_nextScaleGtoP(nextScaleGtoP)
 {
 }
 
@@ -325,8 +323,9 @@ void ApplyLineFeature::ProcessRule(Stylist::rule_wrapper_t const & rule)
     params.m_depth = depth;
     params.m_text = m_captions.GetPathName();
     params.m_textFont = fontDecl;
+    params.m_baseGtoPScale = m_currentScaleGtoP;
 
-    m_context.InsertShape(m_tileKey, dp::MovePointer<MapShape>(new PathTextShape(m_spline, params, m_currentScaleGtoP)));
+    m_context.InsertShape(m_tileKey, dp::MovePointer<MapShape>(new PathTextShape(m_spline, params)));
   }
 
   if (pLineRule != NULL)
diff --git a/drape_frontend/apply_feature_functors.hpp b/drape_frontend/apply_feature_functors.hpp
index 2898d4c5e4..740b4b8a15 100644
--- a/drape_frontend/apply_feature_functors.hpp
+++ b/drape_frontend/apply_feature_functors.hpp
@@ -88,8 +88,7 @@ public:
                    TileKey tileKey,
                    FeatureID const & id,
                    CaptionDescription const & captions,
-                   double currentScaleGtoP,
-                   double nextScaleGtoP);
+                   double currentScaleGtoP);
 
   void operator ()(CoordPointT const & point);
   bool HasGeometry() const;
@@ -99,7 +98,6 @@ public:
 private:
   m2::SharedSpline m_spline;
   double m_currentScaleGtoP;
-  double m_nextScaleGtoP;
 };
 
 } // namespace df
diff --git a/drape_frontend/path_text_shape.cpp b/drape_frontend/path_text_shape.cpp
index c0c7a495e8..261f0bee94 100644
--- a/drape_frontend/path_text_shape.cpp
+++ b/drape_frontend/path_text_shape.cpp
@@ -22,7 +22,6 @@
 #include "../std/vector.hpp"
 
 using m2::Spline;
-using glsl_types::vec2;
 
 namespace
 {
@@ -95,9 +94,9 @@ namespace
     void GetAttributeMutation(dp::RefPointer<dp::AttributeBufferMutator> mutator, ScreenBase const & screen) const
     {
       ASSERT(IsValid(), ());
-      uint32_t byteCount = 4 * m_layout->GetGlyphCount() * sizeof(glsl_types::vec2);
+      uint32_t byteCount = 4 * m_layout->GetGlyphCount() * sizeof(glsl::vec2);
       void * buffer = mutator->AllocateMutationBuffer(byteCount);
-      df::IntrusiveVector<glsl_types::vec2> positions(buffer, byteCount);
+      df::IntrusiveVector<glsl::vec2> positions(buffer, byteCount);
       // m_splineOffset set offset to Center of text.
       // By this we calc offset for start of text in mercator
       m_layout->LayoutPathText(m_begin, m_scalePtoG, positions, m_isForward, m_bboxes, screen);
@@ -138,10 +137,10 @@ namespace
                       float depth,
                       dp::RefPointer<dp::Batcher> batcher,
                       df::SharedTextLayout const & layout,
-                      vector<glsl_types::vec2> & positions,
-                      vector<glsl_types::Quad4> & texCoord,
-                      vector<glsl_types::Quad4> & fontColor,
-                      vector<glsl_types::Quad1> & index,
+                      vector<glsl::vec2> & positions,
+                      vector<glsl::Quad4> & texCoord,
+                      vector<glsl::Quad4> & fontColor,
+                      vector<glsl::Quad1> & index,
                       dp::RefPointer<dp::TextureSetHolder> textures)
   {
     ASSERT(!offsets.empty(), ());
@@ -205,11 +204,9 @@ namespace df
 {
 
 PathTextShape::PathTextShape(m2::SharedSpline const & spline,
-                             PathTextViewParams const & params,
-                             float const scaleGtoP)
+                             PathTextViewParams const & params)
   : m_spline(spline)
   , m_params(params)
-  , m_scaleGtoP(scaleGtoP)
 {
 }
 
@@ -231,10 +228,10 @@ void PathTextShape::Draw(dp::RefPointer<dp::Batcher> batcher, dp::RefPointer<dp:
   float const pathGlbLength = m_spline->GetLength();
 
   // on next readable scale m_scaleGtoP will be twice
-  if (textLength > pathGlbLength * 2 * m_scaleGtoP)
+  if (textLength > pathGlbLength * 2 * m_params.m_baseGtoPScale)
     return;
 
-  float const pathLength = m_scaleGtoP * m_spline->GetLength();
+  float const pathLength = m_params.m_baseGtoPScale * m_spline->GetLength();
 
   /// copied from old code
   /// @todo Choose best constant for minimal space.
@@ -242,13 +239,13 @@ void PathTextShape::Draw(dp::RefPointer<dp::Batcher> batcher, dp::RefPointer<dp:
   float const minPeriodSize = etalonEmpty + textLength;
   float const twoTextAndEmpty = minPeriodSize + textLength;
 
-  vector<glsl_types::vec2>  positions(glyphCount, vec2(0.0, 0.0));
-  vector<glsl_types::Quad4> texCoords(glyphCount);
-  vector<glsl_types::Quad4> fontColor(glyphCount);
-  vector<glsl_types::Quad1> index(glyphCount);
+  vector<glsl::vec2>  positions(glyphCount, glsl::vec2(0.0, 0.0));
+  vector<glsl::Quad4> texCoords(glyphCount);
+  vector<glsl::Quad4> fontColor(glyphCount);
+  vector<glsl::Quad1> index(glyphCount);
   buffer_vector<float, 32> offsets;
 
-  float const scalePtoG = 1.0f / m_scaleGtoP;
+  float const scalePtoG = 1.0f / m_params.m_baseGtoPScale;
 
   if (pathLength < twoTextAndEmpty)
   {
diff --git a/drape_frontend/path_text_shape.hpp b/drape_frontend/path_text_shape.hpp
index 3921ed6132..3468665cca 100644
--- a/drape_frontend/path_text_shape.hpp
+++ b/drape_frontend/path_text_shape.hpp
@@ -2,13 +2,7 @@
 
 #include "map_shape.hpp"
 #include "shape_view_params.hpp"
-#include "common_structures.hpp"
 
-#include "../drape/overlay_handle.hpp"
-
-#include "../std/vector.hpp"
-
-#include "../geometry/point2d.hpp"
 #include "../geometry/spline.hpp"
 
 namespace df
@@ -18,14 +12,12 @@ class PathTextShape : public MapShape
 {
 public:
   PathTextShape(m2::SharedSpline const & spline,
-                PathTextViewParams const & params,
-                float const scaleGtoP);
+                PathTextViewParams const & params);
   virtual void Draw(dp::RefPointer<dp::Batcher> batcher, dp::RefPointer<dp::TextureSetHolder> textures) const;
 
 private:
   m2::SharedSpline m_spline;
   PathTextViewParams m_params;
-  float const m_scaleGtoP;
 };
 
 } // namespace df
diff --git a/drape_frontend/rule_drawer.cpp b/drape_frontend/rule_drawer.cpp
index 3ed7c5f713..083c31894d 100644
--- a/drape_frontend/rule_drawer.cpp
+++ b/drape_frontend/rule_drawer.cpp
@@ -24,11 +24,6 @@ RuleDrawer::RuleDrawer(drawer_callback_fn const & fn, TileKey const & tileKey, E
   m_geometryConvertor.OnSize(0, 0, tileSize, tileSize);
   m_geometryConvertor.SetFromRect(m2::AnyRectD(m_globalRect));
   m_currentScaleGtoP = 1.0f / m_geometryConvertor.GetScale();
-
-  int nextDrawScale = df::GetDrawTileScale(m_globalRect) + 1;
-  m2::RectD nextScaleRect = df::GetRectForDrawScale(nextDrawScale, m_globalRect.Center());
-  ScreenBase nextScaleScreen(m2::RectI(m_geometryConvertor.PixelRect()), m2::AnyRectD(nextScaleRect));
-  m_nextScaleGtoP = 1.0f / nextScaleScreen.GetScale();
 }
 
 void RuleDrawer::operator()(FeatureType const & f)
@@ -67,7 +62,7 @@ void RuleDrawer::operator()(FeatureType const & f)
   {
     ApplyLineFeature apply(m_context, m_tileKey, f.GetID(),
                            s.GetCaptionDescription(),
-                           m_currentScaleGtoP, m_nextScaleGtoP);
+                           m_currentScaleGtoP);
     f.ForEachPointRef(apply, m_tileKey.m_zoomLevel);
 
     if (apply.HasGeometry())
diff --git a/drape_frontend/rule_drawer.hpp b/drape_frontend/rule_drawer.hpp
index 1b845c6972..f80952d28a 100644
--- a/drape_frontend/rule_drawer.hpp
+++ b/drape_frontend/rule_drawer.hpp
@@ -34,7 +34,6 @@ private:
   m2::RectD m_globalRect;
   ScreenBase m_geometryConvertor;
   double m_currentScaleGtoP;
-  double m_nextScaleGtoP;
   set<string> m_coastlines;
 };
 
diff --git a/drape_frontend/shape_view_params.hpp b/drape_frontend/shape_view_params.hpp
index c616e0dd96..04d8ce2091 100644
--- a/drape_frontend/shape_view_params.hpp
+++ b/drape_frontend/shape_view_params.hpp
@@ -72,6 +72,7 @@ struct PathTextViewParams : CommonViewParams
 {
   FontDecl m_textFont;
   string m_text;
+  float m_baseGtoPScale;
 };
 
 struct PathSymbolViewParams : CommonViewParams
diff --git a/drape_frontend/text_layout.cpp b/drape_frontend/text_layout.cpp
index 12c64141d9..c95a519043 100644
--- a/drape_frontend/text_layout.cpp
+++ b/drape_frontend/text_layout.cpp
@@ -1,33 +1,33 @@
 #include "text_layout.hpp"
 
+#include "../drape/glsl_func.hpp"
+
+#include "../drape/overlay_handle.hpp"
+
 #include "../std/numeric.hpp"
 #include "../std/algorithm.hpp"
 #include "../std/bind.hpp"
-#include "../std/algorithm.hpp"
 #include "../std/limits.hpp"
 
-using glsl_types::vec4;
-using glsl_types::Quad1;
-using glsl_types::Quad4;
-
 namespace
 {
-void FillColor(vector<Quad4> & colors,
+
+void FillColor(vector<glsl::Quad4> & colors,
                dp::TextureSetHolder::ColorRegion & region,
                dp::Color const & base, dp::Color const & outline,
                dp::RefPointer<dp::TextureSetHolder> textures)
-  {
+{
   dp::ColorKey key(base.GetColorInInt());
   textures->GetColorRegion(key, region);
-  m2::RectF const & rect = region.GetTexRect();
+  m2::PointF const color = region.GetTexRect().Center();
   key.SetColor(outline.GetColorInInt());
   textures->GetColorRegion(key, region);
-  m2::RectF const & outlineRect = region.GetTexRect();
+  m2::PointF const mask = region.GetTexRect().Center();
+
+  glsl::vec4 clrs(color.x, color.y, mask.x, mask.y);
+  fill(colors.begin(), colors.end(), glsl::Quad4(clrs, clrs, clrs, clrs));
+}
 
-  vec4 clrs(rect.RightTop(), outlineRect.RightTop());
-  Quad4 f(clrs, clrs, clrs, clrs);
-  fill(colors.begin(), colors.end(), f);
-  }
 }
 
 namespace df
@@ -36,8 +36,8 @@ namespace df
 class StraightTextHandle : public dp::OverlayHandle
 {
 public:
-  StraightTextHandle(FeatureID const & id, m2::PointD const & pivot,
-                     m2::PointD const & pxSize, m2::PointD const & offset,
+  StraightTextHandle(FeatureID const & id, glsl::vec2 const & pivot,
+                     glsl::vec2 const & pxSize, glsl::vec2 const & offset,
                      double priority)
     : OverlayHandle(id, dp::LeftBottom, priority)
     , m_pivot(pivot)
@@ -48,8 +48,8 @@ public:
 
   m2::RectD GetPixelRect(ScreenBase const & screen) const
   {
-    m2::PointD const pivot = screen.GtoP(m_pivot) + m_offset;
-    return m2::RectD(pivot, pivot + m_size);
+    m2::PointD const pivot = screen.GtoP(m2::PointD(m_pivot.x, m_pivot.y)) + m2::PointD(m_offset.x, m_offset.y);
+    return m2::RectD(pivot, pivot + m2::PointD(m_size.x, m_size.y));
   }
 
   void GetPixelShape(ScreenBase const & screen, Rects & rects) const
@@ -58,9 +58,9 @@ public:
     rects.push_back(m2::RectF(rd.minX(), rd.minY(), rd.maxX(), rd.maxY()));
   }
 private:
-  m2::PointD m_pivot;
-  m2::PointD m_offset;
-  m2::PointD m_size;
+  glsl::vec2 m_pivot;
+  glsl::vec2 m_offset;
+  glsl::vec2 m_size;
 };
 
 namespace
@@ -99,30 +99,30 @@ TextLayout::TextLayout(strings::UniString const & string,
 #endif
 }
 
-dp::OverlayHandle * LayoutText(const FeatureID & featureID,
-                               m2::PointF const & pivot,
+dp::OverlayHandle * LayoutText(FeatureID const & featureID,
+                               glsl::vec2 const & pivot,
                                vector<TextLayout>::iterator & layoutIter,
-                               vector<m2::PointF>::iterator & pixelOffsetIter,
+                               vector<glsl::vec2>::iterator & pixelOffsetIter,
                                float depth,
-                               vector<glsl_types::Quad4> & positions,
-                               vector<glsl_types::Quad4> & texCoord,
-                               vector<glsl_types::Quad4> & color,
-                               vector<glsl_types::Quad1> & index,
+                               vector<glsl::Quad4> & positions,
+                               vector<glsl::Quad4> & texCoord,
+                               vector<glsl::Quad4> & color,
+                               vector<glsl::Quad1> & index,
                                dp::RefPointer<dp::TextureSetHolder> textures,
                                int count)
 {
-  STATIC_ASSERT(sizeof(vec4) == 4 * sizeof(float));
-  STATIC_ASSERT(sizeof(Quad4) == 4 * sizeof(vec4));
+  STATIC_ASSERT(sizeof(glsl::vec4) == 4 * sizeof(float));
+  STATIC_ASSERT(sizeof(glsl::Quad4) == 4 * sizeof(glsl::vec4));
 
   dp::TextureSetHolder::ColorRegion region;
   FillColor(color, region, layoutIter->m_font.m_color, layoutIter->m_font.m_outlineColor, textures);
-  float texIndex = static_cast<float>(region.GetTextureNode().m_textureOffset);
-  Quad1 f(texIndex, texIndex, texIndex, texIndex);
+  float texIndex = region.GetTextureNode().GetOffset();
+  glsl::Quad1 f(texIndex, texIndex, texIndex, texIndex);
   fill(index.begin(), index.end(), f);
 
   int counter = 0;
-  m2::PointD size(0.0, 0.0);
-  m2::PointF offset(numeric_limits<float>::max(), numeric_limits<float>::max());
+  glsl::vec2 size(0.0, 0.0);
+  glsl::vec2 offset(numeric_limits<float>::max(), numeric_limits<float>::max());
   float maxOffset = numeric_limits<float>::min();
   for (int j = 0; j < count; ++j)
   {
@@ -152,19 +152,19 @@ dp::OverlayHandle * LayoutText(const FeatureID & featureID,
       maxHeight = max((float)h, maxHeight);
       minHeight = min(yOffset, minHeight);
 
-      Quad4 & position = positions[counter++];
-      position.v[0] = vec4(pivot, m2::PointF(glyphOffset + xOffset, yOffset) + *pixelOffsetIter);
-      position.v[1] = vec4(pivot, m2::PointF(glyphOffset + xOffset, yOffset + h) + *pixelOffsetIter);
-      position.v[2] = vec4(pivot, m2::PointF(glyphOffset + w + xOffset, yOffset) + *pixelOffsetIter);
-      position.v[3] = vec4(pivot, m2::PointF(glyphOffset + w + xOffset, yOffset + h) + *pixelOffsetIter);
+      glsl::Quad4 & position = positions[counter++];
+      position[0] = glsl::vec4(pivot, glsl::vec2(glyphOffset + xOffset, yOffset) + *pixelOffsetIter);
+      position[1] = glsl::vec4(pivot, glsl::vec2(glyphOffset + xOffset, yOffset + h) + *pixelOffsetIter);
+      position[2] = glsl::vec4(pivot, glsl::vec2(glyphOffset + w + xOffset, yOffset) + *pixelOffsetIter);
+      position[3] = glsl::vec4(pivot, glsl::vec2(glyphOffset + w + xOffset, yOffset + h) + *pixelOffsetIter);
       glyphOffset += advance;
     }
     glyphOffset += w / 2.0f;
-    size.x = max(size.x, (double)glyphOffset);
+    size.x = max(size.x, glyphOffset);
     offset.x = min(offset.x, pixelOffsetIter->x);
     offset.y = min(offset.y, pixelOffsetIter->y + minHeight);
     maxOffset = max(maxOffset, pixelOffsetIter->y + minHeight);
-    size.y = max(size.y, (double)maxHeight);
+    size.y = max(size.y, maxHeight);
     ++layoutIter;
     ++pixelOffsetIter;
   }
@@ -173,13 +173,13 @@ dp::OverlayHandle * LayoutText(const FeatureID & featureID,
 }
 
 void TextLayout::InitPathText(float depth,
-                              vector<glsl_types::Quad4> & texCoord,
-                              vector<glsl_types::Quad4> & fontColor,
-                              vector<glsl_types::Quad1> & index,
+                              vector<glsl::Quad4> & texCoord,
+                              vector<glsl::Quad4> & fontColor,
+                              vector<glsl::Quad1> & index,
                               dp::RefPointer<dp::TextureSetHolder> textures) const
 {
-  STATIC_ASSERT(sizeof(vec4) == 4 * sizeof(float));
-  STATIC_ASSERT(sizeof(Quad4) == 4 * sizeof(vec4));
+  STATIC_ASSERT(sizeof(glsl::vec4) == 4 * sizeof(float));
+  STATIC_ASSERT(sizeof(glsl::Quad4) == 4 * sizeof(glsl::vec4));
 
   size_t glyphCount = GetGlyphCount();
   ASSERT(glyphCount <= texCoord.size(), ());
@@ -188,8 +188,8 @@ void TextLayout::InitPathText(float depth,
 
   dp::TextureSetHolder::ColorRegion region;
   FillColor(fontColor, region, m_font.m_color, m_font.m_outlineColor, textures);
-  float texIndex = static_cast<float>(region.GetTextureNode().m_textureOffset);
-  Quad1 f(texIndex, texIndex, texIndex, texIndex);
+  float texIndex = region.GetTextureNode().GetOffset();
+  glsl::Quad1 f(texIndex, texIndex, texIndex, texIndex);
   fill(index.begin(), index.end(), f);
 
   for (size_t i = 0; i < glyphCount; ++i)
@@ -198,7 +198,7 @@ void TextLayout::InitPathText(float depth,
 
 void TextLayout::LayoutPathText(m2::Spline::iterator const & iterator,
                                 float const scalePtoG,
-                                IntrusiveVector<glsl_types::vec2> & positions,
+                                IntrusiveVector<glsl::vec2> & positions,
                                 bool isForwardDirection,
                                 vector<m2::RectF> & rects,
                                 ScreenBase const & screen) const
@@ -226,14 +226,14 @@ void TextLayout::LayoutPathText(m2::Spline::iterator const & iterator,
     advance *= scalePtoG;
 
     ASSERT_NOT_EQUAL(advance, 0.0, ());
-    m2::PointD pos = itr.m_pos;
+    glsl::vec2 pos = glsl::ToVec2(itr.m_pos);
     double cosa = 1.0;
 
-    m2::PointD dir;
-    m2::PointD posOffset;
+    glsl::vec2 dir;
+    glsl::vec2 posOffset;
     if (itr.GetLength() <= tentacleLength || itr.GetLength() >= itr.GetFullLength() - tentacleLength)
     {
-      dir = itr.m_avrDir.Normalize();
+      dir = glsl::normalize(glsl::ToVec2(itr.m_avrDir));
     }
     else
     {
@@ -241,37 +241,43 @@ void TextLayout::LayoutPathText(m2::Spline::iterator const & iterator,
       leftTentacle.StepBack(tentacleLength);
       rightTentacle = itr;
       rightTentacle.Step(tentacleLength);
-      dir = (-leftTentacle.m_avrDir + rightTentacle.m_avrDir).Normalize();
-      cosa = m2::DotProduct(-leftTentacle.m_avrDir, rightTentacle.m_avrDir) / rightTentacle.m_avrDir.Length() / leftTentacle.m_avrDir.Length();
-      posOffset = (leftTentacle.m_pos + rightTentacle.m_pos) / 2.0;
-      pos = (posOffset + itr.m_pos) / 2.0;
+
+      glsl::vec2 const leftAvrDir = glsl::normalize(glsl::ToVec2(leftTentacle.m_avrDir));
+      glsl::vec2 const rightAvrDir = glsl::normalize(glsl::ToVec2(rightTentacle.m_avrDir));
+      dir = glsl::normalize(rightAvrDir - leftAvrDir);
+      cosa = glsl::dot(-leftAvrDir, leftAvrDir);
+
+      glsl::vec2 const leftPos(glsl::ToVec2(leftTentacle.m_pos));
+      glsl::vec2 const rightPos(glsl::ToVec2(rightTentacle.m_pos));
+      posOffset = (leftPos + rightPos) / 2.0f;
+      pos = (posOffset + glsl::ToVec2(itr.m_pos)) / 2.0f;
     }
 
-    itr.Step(advance + (1.0 - cosa) * advance * 0.7);
+    itr.Step(advance + (1.0 - cosa) * advance * 0.1);
     //ASSERT(!itr.BeginAgain(), ());
 
-    m2::PointD norm(-dir.y, dir.x);
+    glsl::vec2 norm(-dir.y, dir.x);
     dir *= halfWidth * scalePtoG;
     norm *= halfHeight * scalePtoG;
 
-    m2::PointD dirComponent;
+    glsl::vec2 dirComponent;
     if (isForwardDirection)
       dirComponent = dir * xOffset / halfWidth;
     else
-      dirComponent = dir * (2.0 * halfWidth - xOffset) / halfWidth;
+      dirComponent = dir * (2.0f * halfWidth - xOffset) / halfWidth;
 
-    m2::PointD const normalComponent = -norm * incSign * yOffset / halfHeight;
-    m2::PointD const pivot = dirComponent + normalComponent + pos;
+    glsl::vec2 const normalComponent = -norm * (float)incSign * yOffset / halfHeight;
+    glsl::vec2 const pivot = dirComponent + normalComponent + pos;
 
-    positions.PushBack(glsl_types::vec2(pivot - dir + norm));
-    positions.PushBack(glsl_types::vec2(pivot - dir - norm));
-    positions.PushBack(glsl_types::vec2(pivot + dir + norm));
-    positions.PushBack(glsl_types::vec2(pivot + dir - norm));
+    positions.PushBack(glsl::vec2(pivot - dir + norm));
+    positions.PushBack(glsl::vec2(pivot - dir - norm));
+    positions.PushBack(glsl::vec2(pivot + dir + norm));
+    positions.PushBack(glsl::vec2(pivot + dir - norm));
 
-    pos = screen.GtoP(pivot);
+    m2::PointF resPos = screen.GtoP(glsl::ToPoint(pivot));
     float maxDim = max(halfWidth, halfHeight);
     m2::PointF const maxDir(maxDim, maxDim);
-    rects[i] = m2::RectF(pos - maxDir, pos + maxDir);
+    rects[i] = m2::RectF(resPos - maxDir, resPos + maxDir);
   }
 }
 
@@ -298,17 +304,17 @@ float TextLayout::GetPixelHeight() const
 
 void TextLayout::GetTextureQuad(GlyphRegion const & region,
                                 float depth,
-                                Quad4 & quad) const
+                                glsl::Quad4 & quad) const
 {
   ASSERT(region.IsValid(), ());
 
   m2::RectF const & rect = region.GetTexRect();
   uint8_t needOutline = m_font.m_needOutline ? 1 : 0;
   float textureOffset = static_cast<float>((region.GetTextureNode().m_textureOffset << 1) + needOutline);
-  quad.v[0] = vec4(rect.minX(), rect.minY(), textureOffset, depth);
-  quad.v[1] = vec4(rect.minX(), rect.maxY(), textureOffset, depth);
-  quad.v[2] = vec4(rect.maxX(), rect.minY(), textureOffset, depth);
-  quad.v[3] = vec4(rect.maxX(), rect.maxY(), textureOffset, depth);
+  quad[0] = glsl::vec4(rect.minX(), rect.minY(), textureOffset, depth);
+  quad[1] = glsl::vec4(rect.minX(), rect.maxY(), textureOffset, depth);
+  quad[2] = glsl::vec4(rect.maxX(), rect.minY(), textureOffset, depth);
+  quad[3] = glsl::vec4(rect.maxX(), rect.maxY(), textureOffset, depth);
 }
 
 float TextLayout::AccumulateAdvance(double const & currentValue, GlyphRegion const & reg1) const
diff --git a/drape_frontend/text_layout.hpp b/drape_frontend/text_layout.hpp
index 5079e899a0..05dce46091 100644
--- a/drape_frontend/text_layout.hpp
+++ b/drape_frontend/text_layout.hpp
@@ -1,14 +1,14 @@
 #pragma once
 
-#include "common_structures.hpp"
 #include "shape_view_params.hpp"
 #include "intrusive_vector.hpp"
 
+#include "../drape/glsl_types.hpp"
 #include "../drape/pointers.hpp"
 #include "../drape/texture_set_holder.hpp"
-#include "../drape/overlay_handle.hpp"
 
 #include "../geometry/spline.hpp"
+#include "../geometry/screenbase.hpp"
 
 #include "../base/string_utils.hpp"
 #include "../base/buffer_vector.hpp"
@@ -16,6 +16,11 @@
 #include "../std/vector.hpp"
 #include "../std/shared_ptr.hpp"
 
+namespace dp
+{
+  class OverlayHandle;
+}
+
 namespace df
 {
 
@@ -28,13 +33,13 @@ public:
              dp::RefPointer<dp::TextureSetHolder> textures);
 
   void InitPathText(float depth,
-                    vector<glsl_types::Quad4> & texCoord,
-                    vector<glsl_types::Quad4> & fontColor,
-                    vector<glsl_types::Quad1> & index,
+                    vector<glsl::Quad4> & texCoord,
+                    vector<glsl::Quad4> & fontColor,
+                    vector<glsl::Quad1> & index,
                     dp::RefPointer<dp::TextureSetHolder> textures) const;
   void LayoutPathText(m2::Spline::iterator const & iterator,
                       float const scalePtoG,
-                      IntrusiveVector<glsl_types::vec2> & positions,
+                      IntrusiveVector<glsl::vec2> & positions,
                       bool isForwardDirection,
                       vector<m2::RectF> & rects,
                       ScreenBase const & screen) const;
@@ -47,7 +52,7 @@ public:
 private:
   float AccumulateAdvance(double const & currentValue, GlyphRegion const & reg2) const;
   void InitMetric(strings::UniChar const & unicodePoint, dp::RefPointer<dp::TextureSetHolder> textures);
-  void GetTextureQuad(GlyphRegion const & region, float depth, glsl_types::Quad4 & quad) const;
+  void GetTextureQuad(GlyphRegion const & region, float depth, glsl::Quad4 & quad) const;
   void GetMetrics(int32_t const index, float & xOffset, float & yOffset, float & advance,
                   float & halfWidth, float & halfHeight) const;
 
@@ -56,15 +61,15 @@ private:
   df::FontDecl m_font;
   float m_textSizeRatio;
 
-  friend dp::OverlayHandle * LayoutText(const FeatureID & featureID,
-                                        m2::PointF const & pivot,
+  friend dp::OverlayHandle * LayoutText(FeatureID const & featureID,
+                                        glsl::vec2 const & pivot,
                                         vector<TextLayout>::iterator & layoutIter,
-                                        vector<m2::PointF>::iterator & pixelOffsetIter,
+                                        vector<glsl::vec2>::iterator & pixelOffsetIter,
                                         float depth,
-                                        vector<glsl_types::Quad4> & positions,
-                                        vector<glsl_types::Quad4> & texCoord,
-                                        vector<glsl_types::Quad4> & color,
-                                        vector<glsl_types::Quad1> & index,
+                                        vector<glsl::Quad4> & positions,
+                                        vector<glsl::Quad4> & texCoord,
+                                        vector<glsl::Quad4> & color,
+                                        vector<glsl::Quad1> & index,
                                         dp::RefPointer<dp::TextureSetHolder> textures,
                                         int count);
 };
diff --git a/drape_frontend/text_shape.cpp b/drape_frontend/text_shape.cpp
index 1313468f4f..d207b6b983 100644
--- a/drape_frontend/text_shape.cpp
+++ b/drape_frontend/text_shape.cpp
@@ -1,55 +1,48 @@
 #include "text_shape.hpp"
-#include "common_structures.hpp"
 #include "text_layout.hpp"
 #include "fribidi.hpp"
 
+#include "../drape/glsl_types.hpp"
 #include "../drape/shader_def.hpp"
 #include "../drape/attribute_provider.hpp"
 #include "../drape/glstate.hpp"
 #include "../drape/batcher.hpp"
 #include "../drape/texture_set_holder.hpp"
 
-#include "../base/math.hpp"
-#include "../base/logging.hpp"
-#include "../base/stl_add.hpp"
 #include "../base/string_utils.hpp"
 
-#include "../std/algorithm.hpp"
 #include "../std/vector.hpp"
 
-using m2::PointF;
-
 namespace df
 {
 
-using m2::PointF;
-
 namespace
 {
+
 float const TEXT_EXPAND_FACTOR = 1.3f;
 
-PointF GetShift(dp::Anchor anchor, float width, float height)
+glsl::vec2 GetShift(dp::Anchor anchor, float width, float height)
 {
   switch(anchor)
   {
-  case dp::Center:      return PointF(-width / 2.0f, height / 2.0f);
-  case dp::Left:        return PointF(0.0f, height / 2.0f);
-  case dp::Right:       return PointF(-width, height / 2.0f);
-  case dp::Top:         return PointF(-width / 2.0f, height);
-  case dp::Bottom:      return PointF(-width / 2.0f, 0);
-  case dp::LeftTop:     return PointF(0.0f, height);
-  case dp::RightTop:    return PointF(-width, height);
-  case dp::LeftBottom:  return PointF(0.0f, 0.0f);
-  case dp::RightBottom: return PointF(-width, 0.0f);
-  default:              return PointF(0.0f, 0.0f);
+  case dp::Center:      return glsl::vec2(-width / 2.0f, height / 2.0f);
+  case dp::Left:        return glsl::vec2(0.0f, height / 2.0f);
+  case dp::Right:       return glsl::vec2(-width, height / 2.0f);
+  case dp::Top:         return glsl::vec2(-width / 2.0f, height);
+  case dp::Bottom:      return glsl::vec2(-width / 2.0f, 0);
+  case dp::LeftTop:     return glsl::vec2(0.0f, height);
+  case dp::RightTop:    return glsl::vec2(-width, height);
+  case dp::LeftBottom:  return glsl::vec2(0.0f, 0.0f);
+  case dp::RightBottom: return glsl::vec2(-width, 0.0f);
+  default:              return glsl::vec2(0.0f, 0.0f);
   }
 }
 
 void BatchText(dp::RefPointer<dp::Batcher> batcher, int32_t textureSet,
-               vector<glsl_types::Quad4> const & positions,
-               vector<glsl_types::Quad4> const & texCoord,
-               vector<glsl_types::Quad4> const & color,
-               vector<glsl_types::Quad1> const & index,
+               vector<glsl::Quad4> const & positions,
+               vector<glsl::Quad4> const & texCoord,
+               vector<glsl::Quad4> const & color,
+               vector<glsl::Quad1> const & index,
                size_t glyphCount,
                dp::OverlayHandle * handle)
 {
@@ -255,30 +248,32 @@ void TextShape::DrawMultipleLines(dp::RefPointer<dp::Batcher> batcher, vector<Te
     maxCount = max(maxCount, layouts[i].GetGlyphCount());
   }
 
-  PointF const anchorOffset = GetShift(m_params.m_anchor, maxLength, textHeight * TEXT_EXPAND_FACTOR);
+  glsl::vec2 const anchorOffset = GetShift(m_params.m_anchor, maxLength, textHeight * TEXT_EXPAND_FACTOR);
 
-  vector<glsl_types::Quad4> positions(symCount);
-  vector<glsl_types::Quad4> texCoord(symCount);
-  vector<glsl_types::Quad4> fontColor(symCount);
-  vector<glsl_types::Quad1> indexes(symCount);
+  vector<glsl::Quad4> positions(symCount);
+  vector<glsl::Quad4> texCoord(symCount);
+  vector<glsl::Quad4> fontColor(symCount);
+  vector<glsl::Quad1> indexes(symCount);
 
   float dy = (1.0f - TEXT_EXPAND_FACTOR) * heights[0];
-  vector<PointF> pixelOffset(count);
+  vector<glsl::vec2> pixelOffset(count);
   uint32_t delSymCount = 0;
   uint32_t lastIndex = 0;
   vector<TextLayout>::iterator it1;
-  vector<PointF>::iterator it2;
+  vector<glsl::vec2>::iterator it2;
+  glsl::vec2 pivot(m_basePoint.x, m_basePoint.y);
   for (int i = 0; i < count; ++i)
   {
     float const dx = (maxLength - lengths[i]) / 2.0f;
-    pixelOffset[i] = PointF(dx, dy) + anchorOffset + m_params.m_primaryOffset;
+    pixelOffset[i] = glsl::vec2(dx, dy) + anchorOffset + glsl::vec2(m_params.m_primaryOffset.x,
+                                                                    m_params.m_primaryOffset.y);
     dy -= heights[i] * TEXT_EXPAND_FACTOR;
     delSymCount += layouts[i].GetGlyphCount();
     if (i == delim)
     {
       it2 = pixelOffset.begin();
       it1 = layouts.begin();
-      dp::OverlayHandle * handle = LayoutText(m_params.m_featureID, m_basePoint,
+      dp::OverlayHandle * handle = LayoutText(m_params.m_featureID, pivot,
                                               it1, it2, m_params.m_depth,
                                               positions, texCoord, fontColor,
                                               indexes, textures, i + 1);
@@ -294,7 +289,7 @@ void TextShape::DrawMultipleLines(dp::RefPointer<dp::Batcher> batcher, vector<Te
   }
   it2 = pixelOffset.begin() + lastIndex;
   it1 = layouts.begin() + lastIndex;
-  dp::OverlayHandle * handle = LayoutText(m_params.m_featureID, m_basePoint,
+  dp::OverlayHandle * handle = LayoutText(m_params.m_featureID, pivot,
                                           it1, it2, m_params.m_depth,
                                           positions, texCoord, fontColor, indexes,
                                           textures, count - lastIndex);
diff --git a/drape_frontend/text_shape.hpp b/drape_frontend/text_shape.hpp
index d02ad8ebe4..4332bc3f5a 100644
--- a/drape_frontend/text_shape.hpp
+++ b/drape_frontend/text_shape.hpp
@@ -5,8 +5,6 @@
 
 #include "../geometry/point2d.hpp"
 
-#include "../base/string_utils.hpp"
-
 namespace df
 {