Added Drape API

17 files changed, 544 insertions, 14 deletions

diff --git a/drape_frontend/apply_feature_functors.cpp b/drape_frontend/apply_feature_functors.cpp
index b5982bca70..74688951a0 100644
--- a/drape_frontend/apply_feature_functors.cpp
+++ b/drape_frontend/apply_feature_functors.cpp
@@ -394,7 +394,7 @@ void ApplyPointFeature::Finish()
     params.m_radius = m_circleRule->radius();
     params.m_hasArea = m_hasArea;
     params.m_createdByEditor = m_createdByEditor;
-    m_insertShape(make_unique_dp<CircleShape>(m_centerPoint, params));
+    m_insertShape(make_unique_dp<CircleShape>(m_centerPoint, params, true /* need overlay */));
   }
   else if (m_symbolRule)
   {
diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp
index 0ebbb3911f..d4cd9d8a30 100644
--- a/drape_frontend/backend_renderer.cpp
+++ b/drape_frontend/backend_renderer.cpp
@@ -2,6 +2,7 @@
 
 #include "drape_frontend/backend_renderer.hpp"
 #include "drape_frontend/batchers_pool.hpp"
+#include "drape_frontend/drape_api_builder.hpp"
 #include "drape_frontend/gps_track_shape.hpp"
 #include "drape_frontend/map_shape.hpp"
 #include "drape_frontend/message_subclasses.hpp"
@@ -337,6 +338,7 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
         m_trafficGenerator->AddSegment(segment.first, segment.second);
       break;
     }
+
   case Message::UpdateTraffic:
     {
       ref_ptr<UpdateTrafficMessage> msg = message;
@@ -366,6 +368,27 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
       }
       break;
     }
+
+  case Message::DrapeApiAddLines:
+    {
+      ref_ptr<DrapeApiAddLinesMessage> msg = message;
+      vector<drape_ptr<DrapeApiRenderProperty>> properties;
+      m_drapeApiBuilder->BuildLines(msg->GetLines(), m_texMng, properties);
+      m_commutator->PostMessage(ThreadsCommutator::RenderThread,
+                                make_unique_dp<DrapeApiFlushMessage>(move(properties)),
+                                MessagePriority::Normal);
+      break;
+    }
+
+  case Message::DrapeApiRemove:
+    {
+      ref_ptr<DrapeApiRemoveMessage> msg = message;
+      m_commutator->PostMessage(ThreadsCommutator::RenderThread,
+                                make_unique_dp<DrapeApiRemoveMessage>(msg->GetId(), msg->NeedRemoveAll()),
+                                MessagePriority::Normal);
+      break;
+    }
+
   default:
     ASSERT(false, ());
     break;
diff --git a/drape_frontend/backend_renderer.hpp b/drape_frontend/backend_renderer.hpp
index 39ee36a9ac..d85a22db71 100644
--- a/drape_frontend/backend_renderer.hpp
+++ b/drape_frontend/backend_renderer.hpp
@@ -3,6 +3,7 @@
 #include "drape_frontend/gui/layer_render.hpp"
 
 #include "drape_frontend/base_renderer.hpp"
+#include "drape_frontend/drape_api_builder.hpp"
 #include "drape_frontend/map_data_provider.hpp"
 #include "drape_frontend/overlay_batcher.hpp"
 #include "drape_frontend/requested_tiles.hpp"
@@ -96,6 +97,7 @@ private:
   drape_ptr<ReadManager> m_readManager;
   drape_ptr<RouteBuilder> m_routeBuilder;
   drape_ptr<TrafficGenerator> m_trafficGenerator;
+  drape_ptr<DrapeApiBuilder> m_drapeApiBuilder;
   gui::LayerCacher m_guiCacher;
 
   ref_ptr<RequestedTiles> m_requestedTiles;
diff --git a/drape_frontend/circle_shape.cpp b/drape_frontend/circle_shape.cpp
index 8cdb09bcd4..cd4ec6a189 100644
--- a/drape_frontend/circle_shape.cpp
+++ b/drape_frontend/circle_shape.cpp
@@ -11,11 +11,11 @@
 namespace df
 {
 
-CircleShape::CircleShape(m2::PointF const & mercatorPt, CircleViewParams const & params)
+CircleShape::CircleShape(m2::PointF const & mercatorPt, CircleViewParams const & params, bool needOverlay)
   : m_pt(mercatorPt)
   , m_params(params)
-{
-}
+  , m_needOverlay(needOverlay)
+{}
 
 void CircleShape::Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const
 {
@@ -51,15 +51,20 @@ void CircleShape::Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager>
   dp::GLState state(gpu::TEXTURING_PROGRAM, dp::GLState::OverlayLayer);
   state.SetColorTexture(region.GetTexture());
 
-  double const handleSize = 2 * m_params.m_radius;
-
-  drape_ptr<dp::OverlayHandle> overlay = make_unique_dp<dp::SquareHandle>(m_params.m_id, dp::Center, m_pt,
-                                                                          m2::PointD(handleSize, handleSize),
-                                                                          GetOverlayPriority(), false /* isBound */, "");
-
   dp::AttributeProvider provider(1, TriangleCount + 2);
   provider.InitStream(0, gpu::SolidTexturingVertex::GetBindingInfo(), make_ref(vertexes.data()));
-  batcher->InsertTriangleFan(state, make_ref(&provider), move(overlay));
+  batcher->InsertTriangleFan(state, make_ref(&provider), CreateOverlay());
+}
+
+drape_ptr<dp::OverlayHandle> CircleShape::CreateOverlay() const
+{
+  if (!m_needOverlay)
+    return nullptr;
+
+  double const handleSize = 2 * m_params.m_radius;
+  return make_unique_dp<dp::SquareHandle>(m_params.m_id, dp::Center, m_pt,
+                                          m2::PointD(handleSize, handleSize),
+                                          GetOverlayPriority(), false /* isBound */, "");
 }
 
 uint64_t CircleShape::GetOverlayPriority() const
diff --git a/drape_frontend/circle_shape.hpp b/drape_frontend/circle_shape.hpp
index 93091aae4e..f0e85b58a3 100644
--- a/drape_frontend/circle_shape.hpp
+++ b/drape_frontend/circle_shape.hpp
@@ -3,22 +3,29 @@
 #include "drape_frontend/map_shape.hpp"
 #include "drape_frontend/shape_view_params.hpp"
 
+namespace dp
+{
+class OverlayHandle;
+} // namespace dp
+
 namespace df
 {
 
 class CircleShape : public MapShape
 {
 public:
-  CircleShape(m2::PointF const & mercatorPt, CircleViewParams const & params);
+  CircleShape(m2::PointF const & mercatorPt, CircleViewParams const & params, bool needOverlay);
 
   void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const override;
   MapShapeType GetType() const override { return MapShapeType::OverlayType; }
 
 private:
   uint64_t GetOverlayPriority() const;
+  drape_ptr<dp::OverlayHandle> CreateOverlay() const;
 
   m2::PointF m_pt;
   CircleViewParams m_params;
+  bool m_needOverlay;
 };
 
 } //namespace df
diff --git a/drape_frontend/drape_api.cpp b/drape_frontend/drape_api.cpp
new file mode 100644
index 0000000000..8e00a22b8f
--- /dev/null
+++ b/drape_frontend/drape_api.cpp
@@ -0,0 +1,79 @@
+#include "drape_frontend/drape_api.hpp"
+#include "drape_frontend/drape_engine.hpp"
+#include "drape_frontend/message_subclasses.hpp"
+
+namespace df
+{
+
+void DrapeApi::SetEngine(ref_ptr<DrapeEngine> engine)
+{
+  m_engine = engine;
+}
+
+void DrapeApi::AddLine(string const & id, DrapeApiLineData const & data)
+{
+  lock_guard<mutex> lock(m_mutex);
+
+  if (m_engine == nullptr)
+    return;
+
+  auto it = m_lines.find(id);
+  if (it != m_lines.end())
+  {
+    m_engine->m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
+                                              make_unique_dp<DrapeApiRemoveMessage>(id),
+                                              MessagePriority::Normal);
+  }
+
+  m_lines[id] = data;
+
+  TLines lines;
+  lines.insert(make_pair(id, data));
+  m_engine->m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
+                                            make_unique_dp<DrapeApiAddLinesMessage>(lines),
+                                            MessagePriority::Normal);
+}
+
+void DrapeApi::RemoveLine(string const & id)
+{
+  lock_guard<mutex> lock(m_mutex);
+
+  if (m_engine == nullptr)
+    return;
+
+  m_lines.erase(id);
+  m_engine->m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
+                                            make_unique_dp<DrapeApiRemoveMessage>(id),
+                                            MessagePriority::Normal);
+}
+
+void DrapeApi::Clear()
+{
+  lock_guard<mutex> lock(m_mutex);
+
+  if (m_engine == nullptr)
+    return;
+
+  m_lines.clear();
+  m_engine->m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
+                                            make_unique_dp<DrapeApiRemoveMessage>("", true /* remove all */),
+                                            MessagePriority::Normal);
+}
+
+void DrapeApi::Invalidate()
+{
+  lock_guard<mutex> lock(m_mutex);
+
+  if (m_engine == nullptr)
+    return;
+
+  m_engine->m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
+                                            make_unique_dp<DrapeApiRemoveMessage>("", true /* remove all */),
+                                            MessagePriority::Normal);
+
+  m_engine->m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
+                                            make_unique_dp<DrapeApiAddLinesMessage>(m_lines),
+                                            MessagePriority::Normal);
+}
+
+} // namespace df
diff --git a/drape_frontend/drape_api.hpp b/drape_frontend/drape_api.hpp
new file mode 100644
index 0000000000..4d3b63fcf0
--- /dev/null
+++ b/drape_frontend/drape_api.hpp
@@ -0,0 +1,74 @@
+#pragma once
+
+#include "drape/color.hpp"
+#include "drape/pointers.hpp"
+
+#include "geometry/point2d.hpp"
+
+#include "std/mutex.hpp"
+#include "std/unordered_map.hpp"
+#include "std/vector.hpp"
+
+namespace df
+{
+
+class DrapeEngine;
+
+struct DrapeApiLineData
+{
+  DrapeApiLineData() = default;
+
+  DrapeApiLineData(vector<m2::PointD> const & points, dp::Color const & color)
+    : m_points(points)
+    , m_color(color)
+  {}
+
+  DrapeApiLineData & ShowPoints(bool markPoints)
+  {
+    m_showPoints = true;
+    m_markPoints = markPoints;
+    return *this;
+  }
+
+  DrapeApiLineData & Width(float width)
+  {
+    m_width = width;
+    return *this;
+  }
+
+  DrapeApiLineData & ShowId()
+  {
+    m_showId = true;
+    return *this;
+  }
+
+  vector<m2::PointD> m_points;
+  float m_width = 1.0f;
+  dp::Color m_color;
+
+  bool m_showPoints = false;
+  bool m_markPoints = false;
+  bool m_showId = false;
+};
+
+class DrapeApi
+{
+public:
+  using TLines = unordered_map<string, DrapeApiLineData>;
+
+  DrapeApi() = default;
+
+  void SetEngine(ref_ptr<DrapeEngine> engine);
+
+  void AddLine(string const & id, DrapeApiLineData const & data);
+  void RemoveLine(string const & id);
+  void Clear();
+  void Invalidate();
+
+private:
+  ref_ptr<DrapeEngine> m_engine;
+  TLines m_lines;
+  mutex m_mutex;
+};
+
+} // namespace df
diff --git a/drape_frontend/drape_api_builder.cpp b/drape_frontend/drape_api_builder.cpp
new file mode 100644
index 0000000000..8b2ed13707
--- /dev/null
+++ b/drape_frontend/drape_api_builder.cpp
@@ -0,0 +1,112 @@
+#include "drape_frontend/drape_api_builder.hpp"
+#include "drape_frontend/circle_shape.hpp"
+#include "drape_frontend/gui/gui_text.hpp"
+#include "drape_frontend/line_shape.hpp"
+#include "drape_frontend/shape_view_params.hpp"
+
+#include "drape/batcher.hpp"
+
+#include "indexer/feature_decl.hpp"
+
+#include "base/string_utils.hpp"
+
+namespace
+{
+
+void BuildText(string const & str, dp::FontDecl const & font, m2::PointD const & position,
+               m2::PointD const & center, ref_ptr<dp::TextureManager> textures, dp::Batcher & batcher)
+{
+  gui::StaticLabel::LabelResult result;
+  gui::StaticLabel::CacheStaticText(str, "\n", dp::LeftTop, font, textures, result);
+  glsl::vec2 const pt = glsl::ToVec2(df::MapShape::ConvertToLocal(position, center, df::kShapeCoordScalar));
+  for (gui::StaticLabel::Vertex & v : result.m_buffer)
+    v.m_position = glsl::vec3(pt, 0.0f);
+
+  dp::AttributeProvider provider(1 /* streamCount */, result.m_buffer.size());
+  provider.InitStream(0 /* streamIndex */, gui::StaticLabel::Vertex::GetBindingInfo(),
+                      make_ref(result.m_buffer.data()));
+
+  batcher.InsertListOfStrip(result.m_state, make_ref(&provider), dp::Batcher::VertexPerQuad);
+}
+
+} // namespace
+
+namespace df
+{
+
+void DrapeApiBuilder::BuildLines(DrapeApi::TLines const & lines, ref_ptr<dp::TextureManager> textures,
+                                 vector<drape_ptr<DrapeApiRenderProperty>> & properties)
+{
+  properties.reserve(lines.size());
+
+  uint32_t constexpr kMaxSize = 5000;
+  uint32_t constexpr kFontSize = 14;
+  FeatureID fakeFeature;
+
+  for (auto const & line : lines)
+  {
+    string id = line.first;
+    DrapeApiLineData const & data = line.second;
+    m2::RectD rect;
+    for (m2::PointD p : data.m_points)
+      rect.Add(p);
+
+    dp::Batcher batcher(kMaxSize, kMaxSize);
+    auto property = make_unique_dp<DrapeApiRenderProperty>();
+    property->m_center = rect.Center();
+    {
+      dp::SessionGuard guard(batcher, [&property, id](dp::GLState const & state, drape_ptr<dp::RenderBucket> && b)
+      {
+        property->m_id = id;
+        property->m_buckets.push_back(make_pair(state, move(b)));
+      });
+
+      m2::SharedSpline spline(data.m_points);
+      LineViewParams lvp;
+      lvp.m_tileCenter = property->m_center;
+      lvp.m_depth = 0.0f;
+      lvp.m_minVisibleScale = 1;
+      lvp.m_cap = dp::RoundCap;
+      lvp.m_color = data.m_color;
+      lvp.m_width = data.m_width;
+      lvp.m_join = dp::RoundJoin;
+      LineShape(spline, lvp).Draw(make_ref(&batcher), textures);
+
+      if (data.m_showPoints)
+      {
+        CircleViewParams cvp(fakeFeature);
+        cvp.m_tileCenter = property->m_center;
+        cvp.m_depth = 0.0f;
+        cvp.m_minVisibleScale = 1;
+        cvp.m_color = data.m_color;
+        cvp.m_radius = data.m_width * 2.0f;
+        for (m2::PointD const & pt : data.m_points)
+          CircleShape(m2::PointF(pt), cvp, false /* need overlay */).Draw(make_ref(&batcher), textures);
+      }
+
+      if (data.m_markPoints || data.m_showId)
+      {
+        dp::FontDecl font(data.m_color, kFontSize);
+        size_t index = 0;
+        for (m2::PointD const & pt : data.m_points)
+        {
+          if (index > 0 && !data.m_markPoints) break;
+
+          string s;
+          if (data.m_markPoints)
+            s = strings::to_string(index) + ((data.m_showId && index == 0) ? (" (" + id + ")") : "");
+          else
+            s = id;
+
+          BuildText(s, font, pt, property->m_center, textures, batcher);
+          index++;
+        }
+      }
+    }
+
+    if (!property->m_buckets.empty())
+      properties.push_back(move(property));
+  }
+}
+
+} // namespace df
diff --git a/drape_frontend/drape_api_builder.hpp b/drape_frontend/drape_api_builder.hpp
new file mode 100644
index 0000000000..18afa4f6b9
--- /dev/null
+++ b/drape_frontend/drape_api_builder.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "drape_frontend/drape_api.hpp"
+
+#include "drape/glstate.hpp"
+#include "drape/render_bucket.hpp"
+#include "drape/texture_manager.hpp"
+
+#include "std/string.hpp"
+#include "std/utility.hpp"
+#include "std/vector.hpp"
+
+namespace df
+{
+
+struct DrapeApiRenderProperty
+{
+  string m_id;
+  m2::PointD m_center;
+  vector<pair<dp::GLState, drape_ptr<dp::RenderBucket>>> m_buckets;
+};
+
+class DrapeApiBuilder
+{
+public:
+  DrapeApiBuilder() = default;
+
+  void BuildLines(DrapeApi::TLines const & lines, ref_ptr<dp::TextureManager> textures,
+                  vector<drape_ptr<DrapeApiRenderProperty>> & properties);
+};
+
+} // namespace df
diff --git a/drape_frontend/drape_api_renderer.cpp b/drape_frontend/drape_api_renderer.cpp
new file mode 100644
index 0000000000..7be08987d8
--- /dev/null
+++ b/drape_frontend/drape_api_renderer.cpp
@@ -0,0 +1,77 @@
+#include "drape_frontend/drape_api_renderer.hpp"
+#include "drape_frontend/shape_view_params.hpp"
+#include "drape_frontend/visual_params.hpp"
+
+#include "drape/shader_def.hpp"
+#include "drape/overlay_handle.hpp"
+#include "drape/vertex_array_buffer.hpp"
+
+namespace df
+{
+
+void DrapeApiRenderer::AddRenderProperties(ref_ptr<dp::GpuProgramManager> mng,
+                                           vector<drape_ptr<DrapeApiRenderProperty>> && properties)
+{
+  if (properties.empty())
+    return;
+
+  size_t const startIndex = m_properties.size();
+  m_properties.reserve(m_properties.size() + properties.size());
+  move(properties.begin(), properties.end(), std::back_inserter(m_properties));
+  for (size_t i = startIndex; i < m_properties.size(); i++)
+  {
+    for (auto const & bucket : m_properties[i]->m_buckets)
+    {
+      ref_ptr<dp::GpuProgram> program = mng->GetProgram(bucket.first.GetProgramIndex());
+      program->Bind();
+      bucket.second->GetBuffer()->Build(program);
+    }
+  }
+}
+
+void DrapeApiRenderer::RemoveRenderProperty(string const & id)
+{
+  m_properties.erase(remove_if(m_properties.begin(), m_properties.end(),
+                               [&id](drape_ptr<DrapeApiRenderProperty> const & p)
+                               {
+                                 return p->m_id == id;
+                               }), m_properties.end());
+}
+
+void DrapeApiRenderer::Clear()
+{
+  m_properties.clear();
+}
+
+void DrapeApiRenderer::Render(ScreenBase const & screen, ref_ptr<dp::GpuProgramManager> mng,
+                              dp::UniformValuesStorage const & commonUniforms)
+{
+  if (m_properties.empty())
+    return;
+
+  auto const & params = df::VisualParams::Instance().GetGlyphVisualParams();
+  for (auto const & property : m_properties)
+  {
+    math::Matrix<float, 4, 4> const mv = screen.GetModelView(property->m_center, kShapeCoordScalar);
+    for (auto const & bucket : property->m_buckets)
+    {
+      ref_ptr<dp::GpuProgram> program = mng->GetProgram(bucket.first.GetProgramIndex());
+      program->Bind();
+      dp::ApplyState(bucket.first, program);
+
+      dp::UniformValuesStorage uniforms = commonUniforms;
+      uniforms.SetMatrix4x4Value("modelView", mv.m_data);
+      uniforms.SetFloatValue("u_opacity", 1.0f);
+      if (bucket.first.GetProgramIndex() == gpu::TEXT_OUTLINED_GUI_PROGRAM)
+      {
+        uniforms.SetFloatValue("u_contrastGamma", params.m_guiContrast, params.m_guiGamma);
+        uniforms.SetFloatValue("u_isOutlinePass", 0.0f);
+      }
+      dp::ApplyUniforms(uniforms, program);
+
+      bucket.second->Render(bucket.first.GetDrawAsLine());
+    }
+  }
+}
+
+} // namespace df
diff --git a/drape_frontend/drape_api_renderer.hpp b/drape_frontend/drape_api_renderer.hpp
new file mode 100644
index 0000000000..a50276877b
--- /dev/null
+++ b/drape_frontend/drape_api_renderer.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "drape_frontend/drape_api_builder.hpp"
+
+#include "drape/gpu_program_manager.hpp"
+
+#include "geometry/screenbase.hpp"
+
+#include "std/vector.hpp"
+#include "std/string.hpp"
+
+namespace df
+{
+
+class DrapeApiRenderer
+{
+public:
+  DrapeApiRenderer() = default;
+
+  void AddRenderProperties(ref_ptr<dp::GpuProgramManager> mng,
+                           vector<drape_ptr<DrapeApiRenderProperty>> && properties);
+
+  void RemoveRenderProperty(string const & id);
+  void Clear();
+
+  void Render(ScreenBase const & screen, ref_ptr<dp::GpuProgramManager> mng,
+              dp::UniformValuesStorage const & commonUniforms);
+
+private:
+  vector<drape_ptr<DrapeApiRenderProperty>> m_properties;
+};
+
+} // namespace df
diff --git a/drape_frontend/drape_engine.hpp b/drape_frontend/drape_engine.hpp
index e49a76aa37..d9a9b12df8 100644
--- a/drape_frontend/drape_engine.hpp
+++ b/drape_frontend/drape_engine.hpp
@@ -198,6 +198,8 @@ private:
 
   bool m_choosePositionMode = false;
   bool m_kineticScrollEnabled = true;
+
+  friend class DrapeApi;
 };
 
 } // namespace df
diff --git a/drape_frontend/drape_frontend.pro b/drape_frontend/drape_frontend.pro
index c0d2a44d91..cfbc65a284 100755
--- a/drape_frontend/drape_frontend.pro
+++ b/drape_frontend/drape_frontend.pro
@@ -47,6 +47,9 @@ SOURCES += \
     batch_merge_helper.cpp \
     circle_shape.cpp \
     color_constants.cpp \
+    drape_api.cpp \
+    drape_api_builder.cpp \
+    drape_api_renderer.cpp \
     drape_engine.cpp \
     engine_context.cpp \
     framebuffer.cpp \
@@ -143,6 +146,9 @@ HEADERS += \
     batch_merge_helper.hpp \
     circle_shape.hpp \
     color_constants.hpp \
+    drape_api.hpp \
+    drape_api_builder.hpp \
+    drape_api_renderer.hpp \
     drape_engine.hpp \
     engine_context.hpp \
     framebuffer.hpp \
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index e11db6542c..5e079c0e72 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -118,6 +118,7 @@ FrontendRenderer::FrontendRenderer(Params const & params)
   , m_framebuffer(new Framebuffer())
   , m_transparentLayer(new TransparentLayer())
   , m_gpsTrackRenderer(new GpsTrackRenderer(bind(&FrontendRenderer::PrepareGpsTrackPoints, this, _1)))
+  , m_drapeApiRenderer(new DrapeApiRenderer())
   , m_overlayTree(new dp::OverlayTree())
   , m_enablePerspectiveInNavigation(false)
   , m_enable3dBuildings(params.m_allow3dBuildings)
@@ -759,6 +760,23 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
       break;
     }
 
+  case Message::DrapeApiFlush:
+    {
+      ref_ptr<DrapeApiFlushMessage> msg = message;
+      m_drapeApiRenderer->AddRenderProperties(make_ref(m_gpuProgramManager), msg->AcceptProperties());
+      break;
+    }
+
+  case Message::DrapeApiRemove:
+    {
+      ref_ptr<DrapeApiRemoveMessage> msg = message;
+      if (msg->NeedRemoveAll())
+        m_drapeApiRenderer->Clear();
+      else
+        m_drapeApiRenderer->RemoveRenderProperty(msg->GetId());
+      break;
+    }
+
   default:
     ASSERT(false, ());
   }
@@ -1131,6 +1149,8 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView)
 
   m_myPositionController->Render(modelView, m_currentZoomLevel, make_ref(m_gpuProgramManager), m_generalUniforms);
 
+  m_drapeApiRenderer->Render(modelView, make_ref(m_gpuProgramManager), m_generalUniforms);
+
   if (m_guiRenderer != nullptr)
     m_guiRenderer->Render(make_ref(m_gpuProgramManager), modelView);
 
@@ -1580,6 +1600,7 @@ void FrontendRenderer::OnContextDestroy()
   m_routeRenderer->ClearGLDependentResources();
   m_gpsTrackRenderer->ClearRenderData();
   m_trafficRenderer->Clear();
+  m_drapeApiRenderer->Clear();
 
 #ifdef RENDER_DEBUG_RECTS
   dp::DebugRectRenderer::Instance().Destroy();
diff --git a/drape_frontend/frontend_renderer.hpp b/drape_frontend/frontend_renderer.hpp
index 1dfdb783ee..aef7936f35 100755
--- a/drape_frontend/frontend_renderer.hpp
+++ b/drape_frontend/frontend_renderer.hpp
@@ -12,6 +12,7 @@
 
 #include "drape_frontend/backend_renderer.hpp"
 #include "drape_frontend/base_renderer.hpp"
+#include "drape_frontend/drape_api_renderer.hpp"
 #include "drape_frontend/gps_track_renderer.hpp"
 #include "drape_frontend/my_position_controller.hpp"
 #include "drape_frontend/navigator.hpp"
@@ -284,6 +285,7 @@ private:
   drape_ptr<Framebuffer> m_framebuffer;
   drape_ptr<TransparentLayer> m_transparentLayer;
   drape_ptr<GpsTrackRenderer> m_gpsTrackRenderer;
+  drape_ptr<DrapeApiRenderer> m_drapeApiRenderer;
 
   drape_ptr<dp::OverlayTree> m_overlayTree;
 
diff --git a/drape_frontend/message.hpp b/drape_frontend/message.hpp
index 43aa925a57..a2e7fb7d16 100644
--- a/drape_frontend/message.hpp
+++ b/drape_frontend/message.hpp
@@ -68,7 +68,10 @@ public:
     AddTrafficSegments,
     SetTrafficTexCoords,
     UpdateTraffic,
-    FlushTrafficData
+    FlushTrafficData,
+    DrapeApiAddLines,
+    DrapeApiRemove,
+    DrapeApiFlush,
   };
 
   virtual ~Message() {}
diff --git a/drape_frontend/message_subclasses.hpp b/drape_frontend/message_subclasses.hpp
index aafe817b36..dc8e65d4d2 100644
--- a/drape_frontend/message_subclasses.hpp
+++ b/drape_frontend/message_subclasses.hpp
@@ -4,6 +4,8 @@
 #include "drape_frontend/gui/skin.hpp"
 
 #include "drape_frontend/color_constants.hpp"
+#include "drape_frontend/drape_api.hpp"
+#include "drape_frontend/drape_api_builder.hpp"
 #include "drape_frontend/gps_track_point.hpp"
 #include "drape_frontend/gps_track_shape.hpp"
 #include "drape_frontend/message.hpp"
@@ -1020,7 +1022,7 @@ private:
 class FlushTrafficDataMessage : public Message
 {
 public:
-  FlushTrafficDataMessage(vector<TrafficRenderData> && trafficData)
+  explicit FlushTrafficDataMessage(vector<TrafficRenderData> && trafficData)
     : m_trafficData(move(trafficData))
   {}
 
@@ -1031,4 +1033,54 @@ private:
   vector<TrafficRenderData> m_trafficData;
 };
 
+class DrapeApiAddLinesMessage : public Message
+{
+public:
+  explicit DrapeApiAddLinesMessage(DrapeApi::TLines const & lines)
+    : m_lines(lines)
+  {}
+
+  Type GetType() const override { return Message::DrapeApiAddLines; }
+
+  DrapeApi::TLines const & GetLines() const { return m_lines; }
+
+private:
+  DrapeApi::TLines m_lines;
+};
+
+class DrapeApiRemoveMessage : public Message
+{
+public:
+  explicit DrapeApiRemoveMessage(string const & id, bool removeAll = false)
+    : m_id(id)
+    , m_removeAll(removeAll)
+  {}
+
+  Type GetType() const override { return Message::DrapeApiRemove; }
+
+  string const & GetId() const { return m_id; }
+  bool NeedRemoveAll() const { return m_removeAll; }
+
+private:
+  string m_id;
+  bool m_removeAll;
+};
+
+class DrapeApiFlushMessage : public Message
+{
+public:
+  using TProperties = vector<drape_ptr<DrapeApiRenderProperty>>;
+
+  explicit DrapeApiFlushMessage(TProperties && properties)
+    : m_properties(move(properties))
+  {}
+
+  Type GetType() const override { return Message::DrapeApiFlush; }
+
+  TProperties && AcceptProperties() { return move(m_properties); }
+
+private:
+  TProperties m_properties;
+};
+
 } // namespace df