using separate displayList for straight text elements and drawing them with glUseSharpGeometry enabled.

map/screen_coverage.cpp

@@ -155,17 +155,28 @@ void ScreenCoverage::Merge(Tiler::RectInfo const & ri)
   }
 }
 
+void FilterElementsBySharpness(shared_ptr<yg::OverlayElement> const & e,
+                               vector<shared_ptr<yg::OverlayElement> > & v,
+                               bool flag)
+{
+  if (e->hasSharpGeometry() == flag)
+    v.push_back(e);
+}
+
 bool ScreenCoverage::Cache(core::CommandsQueue::Environment const & env)
 {
   /// caching tiles blitting commands.
 
-  m_displayList.reset();
-  m_displayList.reset(m_cacheScreen->createDisplayList());
+  m_primaryDL.reset();
+  m_primaryDL.reset(m_cacheScreen->createDisplayList());
+
+  m_sharpTextDL.reset();
+  m_sharpTextDL.reset(m_cacheScreen->createDisplayList());
 
   m_cacheScreen->setEnvironment(&env);
 
   m_cacheScreen->beginFrame();
-  m_cacheScreen->setDisplayList(m_displayList.get());
+  m_cacheScreen->setDisplayList(m_primaryDL.get());
 
   vector<yg::gl::BlitInfo> infos;
 
@@ -189,9 +200,28 @@ bool ScreenCoverage::Cache(core::CommandsQueue::Environment const & env)
   if (!infos.empty())
     m_cacheScreen->blit(&infos[0], infos.size(), true);
 
-  m_overlay->draw(m_cacheScreen.get(), math::Identity<double, 3>());
+  math::Matrix<double, 3, 3> idM = math::Identity<double, 3>();
+
+  // selecting and rendering non-sharp elements.
+
+  vector<shared_ptr<yg::OverlayElement> > nonSharpElements;
+  m_overlay->forEach(bind(&FilterElementsBySharpness, _1, ref(nonSharpElements), false));
+
+  for (unsigned i = 0; i < nonSharpElements.size(); ++i)
+    nonSharpElements[i]->draw(m_cacheScreen.get(), idM);
+
+  // selecting and rendering sharp elements
+
+  vector<shared_ptr<yg::OverlayElement> > sharpElements;
+  m_overlay->forEach(bind(&FilterElementsBySharpness, _1, ref(sharpElements), true));
+
+  m_cacheScreen->setDisplayList(m_sharpTextDL.get());
+
+  for (unsigned i = 0; i < sharpElements.size(); ++i)
+    sharpElements[i]->draw(m_cacheScreen.get(), idM);
 
   m_cacheScreen->setDisplayList(0);
+
   m_cacheScreen->endFrame();
 
   /// completing commands that was immediately executed
@@ -382,8 +412,17 @@ ScreenCoverage::~ScreenCoverage()
 
 void ScreenCoverage::Draw(yg::gl::Screen * s, ScreenBase const & screen)
 {
-  if (m_displayList)
-    m_displayList->draw(m_screen.PtoGMatrix() * screen.GtoPMatrix());
+  math::Matrix<double, 3, 3> m = m_screen.PtoGMatrix() * screen.GtoPMatrix();
+
+  if (m_primaryDL)
+    m_primaryDL->draw(m);
+
+  s->setPixelPrecision(true);
+
+  if (m_sharpTextDL)
+    m_sharpTextDL->draw(m);
+
+  s->setPixelPrecision(false);
 }
 
 shared_ptr<yg::Overlay> const & ScreenCoverage::GetOverlay() const

map/screen_coverage.hpp

@@ -70,7 +70,10 @@ private:
   /// Screen, which is used for caching of this ScreenCoverage into DisplayList
   shared_ptr<yg::gl::Screen> m_cacheScreen;
   /// DisplayList which holds cached ScreenCoverage
-  shared_ptr<yg::gl::DisplayList> m_displayList;
+  shared_ptr<yg::gl::DisplayList> m_primaryDL;
+  /// DisplayList to cache all straight texts.
+  /// They are drawn with different shader.
+  shared_ptr<yg::gl::DisplayList> m_sharpTextDL;
 
   /// Direct copying is prohibited.
   ScreenCoverage(ScreenCoverage const & src);

yg/overlay_element.cpp

@@ -200,4 +200,9 @@ namespace yg
 
     return res;
   }
+
+  bool OverlayElement::hasSharpGeometry() const
+  {
+    return false;
+  }
 }

yg/overlay_element.hpp

@@ -103,6 +103,8 @@ namespace yg
     virtual bool roughHitTest(m2::PointD const & pt) const;
 
     m2::RectD const & roughBoundRect() const;
+
+    virtual bool hasSharpGeometry() const;
   };
 
 }

yg/straight_text_element.cpp

@@ -302,4 +302,9 @@ namespace yg
   {
     return new StraightTextElement(*this, m);
   }
+
+  bool StraightTextElement::hasSharpGeometry() const
+  {
+    return true;
+  }
 }

yg/straight_text_element.hpp

@@ -38,5 +38,7 @@ namespace yg
     void setPivot(m2::PointD const & pv);
 
     OverlayElement * clone(math::Matrix<double, 3, 3> const & m) const;
+
+    bool hasSharpGeometry() const;
   };
 }

yg/symbol_element.cpp

@@ -109,4 +109,9 @@ namespace yg
   {
     return new SymbolElement(*this, m);
   }
+
+  bool SymbolElement::hasSharpGeometry() const
+  {
+    return true;
+  }
 }

yg/symbol_element.hpp

@@ -40,5 +40,7 @@ namespace yg
     int visualRank() const;
 
     OverlayElement * clone(math::Matrix<double, 3, 3> const & m) const;
+
+    bool hasSharpGeometry() const;
   };
 }