Framebuffer and render state refactoring.

36 files changed, 502 insertions, 460 deletions

diff --git a/drape_frontend/CMakeLists.txt b/drape_frontend/CMakeLists.txt
index 8340050538..2053d49eb2 100644
--- a/drape_frontend/CMakeLists.txt
+++ b/drape_frontend/CMakeLists.txt
@@ -61,6 +61,8 @@ set(
   colored_symbol_shape.cpp
   colored_symbol_shape.hpp
   custom_features_context.hpp
+  debug_rect_renderer.cpp
+  debug_rect_renderer.hpp
   drape_api.cpp
   drape_api.hpp
   drape_api_builder.cpp
diff --git a/drape_frontend/arrow3d.cpp b/drape_frontend/arrow3d.cpp
index eb1c160cf4..4e08172ef3 100644
--- a/drape_frontend/arrow3d.cpp
+++ b/drape_frontend/arrow3d.cpp
@@ -5,11 +5,6 @@
 
 #include "shaders/program_manager.hpp"
 
-#include "drape/glconstants.hpp"
-#include "drape/glextensions_list.hpp"
-#include "drape/glfunctions.hpp"
-#include "drape/glsl_func.hpp"
-#include "drape/glsl_types.hpp"
 #include "drape/texture_manager.hpp"
 
 #include "indexer/map_style_reader.hpp"
@@ -56,30 +51,9 @@ Arrow3d::Arrow3d()
     0.0f, -0.5f, 0.0f, 1.0f,    0.0f, -0.67f, 0.0f, 0.0f,   -1.2f, -1.0f, 0.0f, 1.0f,
   };
 
-  int constexpr kVerticesInRow = 12;
   std::vector<float> normals;
+  GenerateNormalsForTriangles(vertices, kComponentsInVertex, normals);
   normals.reserve(vertices.size());
-  for (size_t triangle = 0; triangle < vertices.size() / kVerticesInRow; ++triangle)
-  {
-    glsl::vec4 v[3];
-    for (size_t vertex = 0; vertex < 3; ++vertex)
-    {
-      size_t const offset = triangle * kVerticesInRow + vertex * kComponentsInVertex;
-      v[vertex] = glsl::vec4(vertices[offset], vertices[offset + 1],
-                             vertices[offset + 2], vertices[offset + 3]);
-    }
-
-    glsl::vec3 normal = glsl::cross(glsl::vec3(v[1].x - v[0].x, v[1].y - v[0].y, v[1].z - v[0].z),
-                                    glsl::vec3(v[2].x - v[0].x, v[2].y - v[0].y, v[2].z - v[0].z));
-    normal = glsl::normalize(normal);
-
-    for (size_t vertex = 0; vertex < 3; ++vertex)
-    {
-      normals.push_back(normal.x);
-      normals.push_back(normal.y);
-      normals.push_back(normal.z);
-    }
-  }
 
   auto const verticesBufferInd = 0;
   SetBuffer(verticesBufferInd, std::move(vertices), sizeof(float) * kComponentsInVertex);
@@ -110,12 +84,13 @@ void Arrow3d::SetPositionObsolete(bool obsolete)
   m_obsoletePosition = obsolete;
 }
 
-void Arrow3d::Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng, bool routingMode)
+void Arrow3d::Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                     bool routingMode)
 {
   // Render shadow.
   if (screen.isPerspective())
   {
-    RenderArrow(screen, mng, gpu::Program::Arrow3dShadow,
+    RenderArrow(screen, context, mng, gpu::Program::Arrow3dShadow,
                 df::GetColorConstant(df::kArrow3DShadowColor), 0.05f /* dz */,
                 routingMode ? kOutlineScale : 1.0f /* scaleFactor */, false /* hasNormals */);
   }
@@ -127,18 +102,18 @@ void Arrow3d::Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng
   if (routingMode)
   {
     dp::Color const outlineColor = df::GetColorConstant(df::kArrow3DOutlineColor);
-    RenderArrow(screen, mng, gpu::Program::Arrow3dOutline,
+    RenderArrow(screen, context, mng, gpu::Program::Arrow3dOutline,
                 dp::Color(outlineColor.GetRed(), outlineColor.GetGreen(), outlineColor.GetBlue(), color.GetAlpha()),
                 0.0f /* dz */, kOutlineScale /* scaleFactor */, false /* hasNormals */);
   }
 
   // Render arrow.
-  RenderArrow(screen, mng, gpu::Program::Arrow3d, color, 0.0f /* dz */, 1.0f /* scaleFactor */,
+  RenderArrow(screen, context, mng, gpu::Program::Arrow3d, color, 0.0f /* dz */, 1.0f /* scaleFactor */,
               true /* hasNormals */);
 }
 
-void Arrow3d::RenderArrow(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-                          gpu::Program program, dp::Color const & color, float dz,
+void Arrow3d::RenderArrow(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+                          ref_ptr<gpu::ProgramManager> mng, gpu::Program program, dp::Color const & color, float dz,
                           float scaleFactor, bool hasNormals)
 {
   gpu::Arrow3dProgramParams params;
@@ -147,13 +122,7 @@ void Arrow3d::RenderArrow(ScreenBase const & screen, ref_ptr<gpu::ProgramManager
   params.m_color = glsl::ToVec4(color);
 
   auto gpuProgram = mng->GetProgram(program);
-  TBase::Render(gpuProgram,
-                [this, mng, gpuProgram, &params]()
-                {
-                  dp::ApplyState(m_state, gpuProgram);
-                  mng->GetParamsSetter()->Apply(gpuProgram, params);
-                },
-                nullptr);
+  TBase::Render(context, gpuProgram, m_state, mng->GetParamsSetter(), params);
 }
 
 math::Matrix<float, 4, 4> Arrow3d::CalculateTransform(ScreenBase const & screen, float dz, float scaleFactor) const
diff --git a/drape_frontend/arrow3d.hpp b/drape_frontend/arrow3d.hpp
index 3224f8b8fa..4d170b4046 100644
--- a/drape_frontend/arrow3d.hpp
+++ b/drape_frontend/arrow3d.hpp
@@ -35,13 +35,13 @@ public:
   void SetTexture(ref_ptr<dp::TextureManager> texMng);
   void SetPositionObsolete(bool obsolete);
 
-  void Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
+  void Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
               bool routingMode);
 
 private:
   math::Matrix<float, 4, 4> CalculateTransform(ScreenBase const & screen, float dz,
                                                float scaleFactor) const;
-  void RenderArrow(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
+  void RenderArrow(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
                    gpu::Program program, dp::Color const & color, float dz, float scaleFactor,
                    bool hasNormals);
 
diff --git a/drape_frontend/colored_symbol_shape.cpp b/drape_frontend/colored_symbol_shape.cpp
index 6cdd3ecb49..d806621cef 100644
--- a/drape_frontend/colored_symbol_shape.cpp
+++ b/drape_frontend/colored_symbol_shape.cpp
@@ -302,7 +302,7 @@ void ColoredSymbolShape::Draw(ref_ptr<dp::Batcher> batcher,
   state.SetProgram3d(gpu::Program::ColoredSymbolBillboard);
   state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
   state.SetColorTexture(colorRegion.GetTexture());
-  state.SetDepthFunction(dp::DepthFunction::Less);
+  state.SetDepthFunction(dp::TestFunction::Less);
 
   dp::AttributeProvider provider(1, static_cast<uint32_t>(buffer.size()));
   provider.InitStream(0, gpu::ColoredSymbolVertex::GetBindingInfo(), make_ref(buffer.data()));
diff --git a/drape_frontend/debug_rect_renderer.cpp b/drape_frontend/debug_rect_renderer.cpp
new file mode 100644
index 0000000000..f550d4a1e3
--- /dev/null
+++ b/drape_frontend/debug_rect_renderer.cpp
@@ -0,0 +1,121 @@
+#include "drape_frontend/debug_rect_renderer.hpp"
+#include "drape_frontend/render_state_extension.hpp"
+
+#include <vector>
+
+namespace df
+{
+namespace
+{
+void PixelPointToScreenSpace(ScreenBase const & screen, m2::PointF const & pt, std::vector<float> & buffer)
+{
+  auto const szX = static_cast<float>(screen.PixelRectIn3d().SizeX());
+  auto const szY = static_cast<float>(screen.PixelRectIn3d().SizeY());
+
+  buffer.push_back(2.0f * (pt.x / szX - 0.5f));
+  buffer.push_back(2.0f * (-pt.y / szY + 0.5f));
+}
+}  // namespace
+
+ref_ptr<DebugRectRenderer> DebugRectRenderer::Instance()
+{
+  static DebugRectRenderer renderer;
+  return make_ref(&renderer);
+}
+
+DebugRectRenderer::DebugRectRenderer()
+  : TBase(DrawPrimitive::LineStrip)
+  , m_state(CreateRenderState(gpu::Program::DebugRect, DepthLayer::OverlayLayer))
+{
+  m_state.SetDepthTestEnabled(false);
+
+  TBase::SetBuffer(0 /*bufferInd*/, {} /* vertices */, static_cast<uint32_t>(sizeof(float) * 2));
+  TBase::SetAttribute("a_position", 0 /* bufferInd*/, 0.0f /* offset */, 2 /* componentsCount */);
+}
+
+DebugRectRenderer::~DebugRectRenderer()
+{
+  ASSERT(!IsInitialized(), ());
+}
+
+void DebugRectRenderer::Init(ref_ptr<dp::GpuProgram> program, ref_ptr<gpu::ProgramParamsSetter> paramsSetter)
+{
+  m_program = program;
+  m_paramsSetter = paramsSetter;
+}
+
+void DebugRectRenderer::Destroy()
+{
+  m_program = nullptr;
+  m_paramsSetter = nullptr;
+  TBase::Reset();
+}
+
+bool DebugRectRenderer::IsEnabled() const
+{
+  return m_isEnabled;
+}
+
+void DebugRectRenderer::SetEnabled(bool enabled)
+{
+  m_isEnabled = enabled;
+}
+
+void DebugRectRenderer::SetArrow(m2::PointF const & arrowStart, m2::PointF const & arrowEnd,
+                                 ScreenBase const & screen)
+{
+  std::vector<float> vertices;
+  m2::PointF const dir = (arrowEnd - arrowStart).Normalize();
+  m2::PointF const side = m2::PointF(-dir.y, dir.x);
+  PixelPointToScreenSpace(screen, arrowStart, vertices);
+  PixelPointToScreenSpace(screen, arrowEnd, vertices);
+  PixelPointToScreenSpace(screen, arrowEnd - dir * 20 + side * 10, vertices);
+  PixelPointToScreenSpace(screen, arrowEnd, vertices);
+  PixelPointToScreenSpace(screen, arrowEnd - dir * 20 - side * 10, vertices);
+
+  TBase::UpdateBuffer(0 /* bufferInd */, std::move(vertices));
+}
+
+void DebugRectRenderer::SetRect(m2::RectF const & rect, ScreenBase const & screen)
+{
+  std::vector<float> vertices;
+  PixelPointToScreenSpace(screen, rect.LeftBottom(), vertices);
+  PixelPointToScreenSpace(screen, rect.LeftTop(), vertices);
+  PixelPointToScreenSpace(screen, rect.RightTop(), vertices);
+  PixelPointToScreenSpace(screen, rect.RightBottom(), vertices);
+  PixelPointToScreenSpace(screen, rect.LeftBottom(), vertices);
+
+  TBase::UpdateBuffer(0 /* bufferInd */, std::move(vertices));
+}
+
+void DebugRectRenderer::DrawRect(ref_ptr<dp::GraphicsContext> context, ScreenBase const & screen,
+                                 m2::RectF const & rect, dp::Color const & color)
+{
+  if (!m_isEnabled)
+    return;
+
+  SetRect(rect, screen);
+
+  gpu::DebugRectProgramParams params;
+  params.m_color = glsl::ToVec4(color);
+
+  TBase::Render(context, m_program, m_state, m_paramsSetter, params);
+};
+
+void DebugRectRenderer::DrawArrow(ref_ptr<dp::GraphicsContext> context, ScreenBase const & screen,
+                                  dp::OverlayTree::DisplacementData const & data)
+{
+  if (!m_isEnabled)
+    return;
+
+  if (data.m_arrowStart.EqualDxDy(data.m_arrowEnd, 1e-5))
+    return;
+
+  SetArrow(data.m_arrowStart, data.m_arrowEnd, screen);
+
+  gpu::DebugRectProgramParams params;
+  params.m_color = glsl::ToVec4(data.m_arrowColor);
+
+  TBase::Render(context, m_program, m_state, m_paramsSetter, params);
+};
+}  // namespace df
diff --git a/drape_frontend/debug_rect_renderer.hpp b/drape_frontend/debug_rect_renderer.hpp
new file mode 100644
index 0000000000..a1b0486df4
--- /dev/null
+++ b/drape_frontend/debug_rect_renderer.hpp
@@ -0,0 +1,49 @@
+#pragma once
+
+#include "drape/debug_renderer.hpp"
+#include "drape/gpu_program.hpp"
+#include "drape/mesh_object.hpp"
+#include "drape/render_state.hpp"
+
+#include "shaders/program_params.hpp"
+
+#include "geometry/rect2d.hpp"
+#include "geometry/screenbase.hpp"
+
+#ifdef BUILD_DESIGNER
+#define RENDER_DEBUG_RECTS
+#endif // BUILD_DESIGNER
+
+namespace df
+{
+class DebugRectRenderer: public dp::MeshObject, public dp::IDebugRenderer
+{
+  using TBase = dp::MeshObject;
+public:
+  static ref_ptr<DebugRectRenderer> Instance();
+
+  void Init(ref_ptr<dp::GpuProgram> program, ref_ptr<gpu::ProgramParamsSetter> paramsSetter);
+  void Destroy();
+  void SetEnabled(bool enabled);
+
+  bool IsEnabled() const override;
+  void DrawRect(ref_ptr<dp::GraphicsContext> context, ScreenBase const & screen,
+                m2::RectF const & rect, dp::Color const & color) override;
+  void DrawArrow(ref_ptr<dp::GraphicsContext> context, ScreenBase const & screen,
+                 dp::OverlayTree::DisplacementData const & data) override;
+
+private:
+  DebugRectRenderer();
+  ~DebugRectRenderer() override;
+
+  void SetArrow(m2::PointF const & arrowStart, m2::PointF const & arrowEnd, ScreenBase const & screen);
+  void SetRect(m2::RectF const & rect, ScreenBase const & screen);
+
+  ref_ptr<dp::GpuProgram> m_program;
+  ref_ptr<gpu::ProgramParamsSetter> m_paramsSetter;
+  dp::RenderState m_state;
+
+  bool m_isEnabled = false;
+};
+}  // namespace df
+
diff --git a/drape_frontend/drape_api_renderer.cpp b/drape_frontend/drape_api_renderer.cpp
index 1192335f20..cb7074cef9 100644
--- a/drape_frontend/drape_api_renderer.cpp
+++ b/drape_frontend/drape_api_renderer.cpp
@@ -41,8 +41,8 @@ void DrapeApiRenderer::Clear()
   m_properties.clear();
 }
 
-void DrapeApiRenderer::Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-                              FrameValues const & frameValues)
+void DrapeApiRenderer::Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+                              ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
 {
   if (m_properties.empty())
     return;
@@ -55,7 +55,7 @@ void DrapeApiRenderer::Render(ScreenBase const & screen, ref_ptr<gpu::ProgramMan
     {
       auto program = mng->GetProgram(bucket.first.GetProgram<gpu::Program>());
       program->Bind();
-      dp::ApplyState(bucket.first, program);
+      dp::ApplyState(bucket.first, context, program);
 
       if (bucket.first.GetProgram<gpu::Program>() == gpu::Program::TextOutlinedGui)
       {
diff --git a/drape_frontend/drape_api_renderer.hpp b/drape_frontend/drape_api_renderer.hpp
index 8cd9c6eb96..f0fa3b9ddb 100644
--- a/drape_frontend/drape_api_renderer.hpp
+++ b/drape_frontend/drape_api_renderer.hpp
@@ -22,8 +22,8 @@ public:
   void RemoveRenderProperty(string const & id);
   void Clear();
 
-  void Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-              FrameValues const & frameValues);
+  void Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+              ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
 
 private:
   std::vector<drape_ptr<DrapeApiRenderProperty>> m_properties;
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index 1267a01c58..1982b7eb8f 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -15,7 +15,7 @@
 
 #include "shaders/programs.hpp"
 
-#include "drape/debug_rect_renderer.hpp"
+#include "drape_frontend/debug_rect_renderer.hpp"
 #include "drape/framebuffer.hpp"
 #include "drape/support_manager.hpp"
 #include "drape/utils/glyph_usage_tracker.hpp"
@@ -1205,9 +1205,9 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView, bool activeFram
   DrapeMeasurer::Instance().BeforeRenderFrame();
 #endif
 
-  auto context = m_contextFactory->GetDrawContext();
+  auto context = make_ref(m_contextFactory->GetDrawContext());
 
-  if (m_postprocessRenderer->BeginFrame(activeFrame))
+  if (m_postprocessRenderer->BeginFrame(context, activeFrame))
   {
     m_viewport.Apply();
     RefreshBgColor();
@@ -1240,29 +1240,29 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView, bool activeFram
       {
         ASSERT(m_myPositionController->IsModeHasPosition(), ());
         m_selectionShape->SetPosition(m_myPositionController->Position());
-        m_selectionShape->Render(modelView, m_currentZoomLevel, make_ref(m_gpuProgramManager),
+        m_selectionShape->Render(modelView, m_currentZoomLevel, context, make_ref(m_gpuProgramManager),
                                  m_frameValues);
       }
       else if (selectedObject == SelectionShape::OBJECT_POI)
       {
-        m_selectionShape->Render(modelView, m_currentZoomLevel, make_ref(m_gpuProgramManager),
+        m_selectionShape->Render(modelView, m_currentZoomLevel, context, make_ref(m_gpuProgramManager),
                                  m_frameValues);
       }
     }
 
     {
-      StencilWriterGuard guard(make_ref(m_postprocessRenderer));
+      StencilWriterGuard guard(make_ref(m_postprocessRenderer), context);
       RenderOverlayLayer(modelView);
       RenderUserMarksLayer(modelView, DepthLayer::LocalAdsMarkLayer);
     }
 
-    m_gpsTrackRenderer->RenderTrack(modelView, m_currentZoomLevel, make_ref(m_gpuProgramManager),
+    m_gpsTrackRenderer->RenderTrack(modelView, m_currentZoomLevel, context, make_ref(m_gpuProgramManager),
                                     m_frameValues);
 
     if (m_selectionShape != nullptr &&
         m_selectionShape->GetSelectedObject() == SelectionShape::OBJECT_USER_MARK)
     {
-      m_selectionShape->Render(modelView, m_currentZoomLevel, make_ref(m_gpuProgramManager),
+      m_selectionShape->Render(modelView, m_currentZoomLevel, context, make_ref(m_gpuProgramManager),
                                m_frameValues);
     }
 
@@ -1270,7 +1270,7 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView, bool activeFram
       RenderRouteLayer(modelView);
 
     {
-      StencilWriterGuard guard(make_ref(m_postprocessRenderer));
+      StencilWriterGuard guard(make_ref(m_postprocessRenderer), context);
       RenderUserMarksLayer(modelView, DepthLayer::UserMarkLayer);
       RenderUserMarksLayer(modelView, DepthLayer::TransitMarkLayer);
       RenderUserMarksLayer(modelView, DepthLayer::RoutingMarkLayer);
@@ -1280,21 +1280,21 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView, bool activeFram
     if (!HasRouteData())
       RenderTransitSchemeLayer(modelView);
 
-    m_drapeApiRenderer->Render(modelView, make_ref(m_gpuProgramManager), m_frameValues);
+    m_drapeApiRenderer->Render(modelView, context, make_ref(m_gpuProgramManager), m_frameValues);
 
     for (auto const & arrow : m_overlayTree->GetDisplacementInfo())
-      dp::DebugRectRenderer::Instance().DrawArrow(modelView, arrow);
+      DebugRectRenderer::Instance()->DrawArrow(context, modelView, arrow);
   }
 
-  if (!m_postprocessRenderer->EndFrame(make_ref(m_gpuProgramManager)))
+  if (!m_postprocessRenderer->EndFrame(context, make_ref(m_gpuProgramManager)))
     return;
 
-  m_myPositionController->Render(modelView, m_currentZoomLevel, make_ref(m_gpuProgramManager),
+  m_myPositionController->Render(modelView, m_currentZoomLevel, context, make_ref(m_gpuProgramManager),
                                  m_frameValues);
 
   if (m_guiRenderer != nullptr)
   {
-    m_guiRenderer->Render(make_ref(m_gpuProgramManager), m_myPositionController->IsInRouting(),
+    m_guiRenderer->Render(context, make_ref(m_gpuProgramManager), m_myPositionController->IsInRouting(),
                           modelView);
   }
 
@@ -1308,8 +1308,9 @@ void FrontendRenderer::Render2dLayer(ScreenBase const & modelView)
   RenderLayer & layer2d = m_layers[static_cast<size_t>(DepthLayer::GeometryLayer)];
   layer2d.Sort(make_ref(m_overlayTree));
 
+  auto context = make_ref(m_contextFactory->GetDrawContext());
   for (drape_ptr<RenderGroup> const & group : layer2d.m_renderGroups)
-    RenderSingleGroup(modelView, make_ref(group));
+    RenderSingleGroup(context, modelView, make_ref(group));
 }
 
 void FrontendRenderer::Render3dLayer(ScreenBase const & modelView, bool useFramebuffer)
@@ -1318,7 +1319,7 @@ void FrontendRenderer::Render3dLayer(ScreenBase const & modelView, bool useFrame
   if (layer.m_renderGroups.empty())
     return;
 
-  auto context = m_contextFactory->GetDrawContext();
+  auto context = make_ref(m_contextFactory->GetDrawContext());
   float const kOpacity = 0.7f;
   if (useFramebuffer)
   {
@@ -1334,23 +1335,24 @@ void FrontendRenderer::Render3dLayer(ScreenBase const & modelView, bool useFrame
 
   layer.Sort(make_ref(m_overlayTree));
   for (drape_ptr<RenderGroup> const & group : layer.m_renderGroups)
-    RenderSingleGroup(modelView, make_ref(group));
+    RenderSingleGroup(context, modelView, make_ref(group));
 
   if (useFramebuffer)
   {
     m_buildingsFramebuffer->Disable();
-    m_screenQuadRenderer->RenderTexture(make_ref(m_gpuProgramManager),
-                                        m_buildingsFramebuffer->GetTextureId(),
+    m_screenQuadRenderer->RenderTexture(context, make_ref(m_gpuProgramManager),
+                                        m_buildingsFramebuffer->GetTexture(),
                                         kOpacity);
   }
 }
 
 void FrontendRenderer::RenderOverlayLayer(ScreenBase const & modelView)
 {
+  auto context = make_ref(m_contextFactory->GetDrawContext());
   RenderLayer & overlay = m_layers[static_cast<size_t>(DepthLayer::OverlayLayer)];
   BuildOverlayTree(modelView);
   for (drape_ptr<RenderGroup> & group : overlay.m_renderGroups)
-    RenderSingleGroup(modelView, make_ref(group));
+    RenderSingleGroup(context, modelView, make_ref(group));
 
   if (GetStyleReader().IsCarNavigationStyle())
     RenderNavigationOverlayLayer(modelView);
@@ -1358,11 +1360,12 @@ void FrontendRenderer::RenderOverlayLayer(ScreenBase const & modelView)
 
 void FrontendRenderer::RenderNavigationOverlayLayer(ScreenBase const & modelView)
 {
+  auto context = make_ref(m_contextFactory->GetDrawContext());
   RenderLayer & navOverlayLayer = m_layers[static_cast<size_t>(DepthLayer::NavigationLayer)];
   for (auto & group : navOverlayLayer.m_renderGroups)
   {
     if (group->HasOverlayHandles())
-      RenderSingleGroup(modelView, make_ref(group));
+      RenderSingleGroup(context, modelView, make_ref(group));
   }
 }
 
@@ -1378,23 +1381,24 @@ bool FrontendRenderer::HasRouteData() const
 
 void FrontendRenderer::RenderTransitSchemeLayer(ScreenBase const & modelView)
 {
-  auto context = m_contextFactory->GetDrawContext();
+  auto context = make_ref(m_contextFactory->GetDrawContext());
   context->Clear(dp::ClearBits::DepthBit);
   if (m_transitSchemeEnabled && m_transitSchemeRenderer->IsSchemeVisible(m_currentZoomLevel))
   {
     RenderTransitBackground();
-    m_transitSchemeRenderer->RenderTransit(modelView, make_ref(m_gpuProgramManager),
-                                           make_ref(m_postprocessRenderer), make_ref(context), m_frameValues);
+    m_transitSchemeRenderer->RenderTransit(modelView, context, make_ref(m_gpuProgramManager),
+                                           make_ref(m_postprocessRenderer), m_frameValues);
   }
 }
 
 void FrontendRenderer::RenderTrafficLayer(ScreenBase const & modelView)
 {
-  m_contextFactory->GetDrawContext()->Clear(dp::ClearBits::DepthBit);
+  auto context = make_ref(m_contextFactory->GetDrawContext());
+  context->Clear(dp::ClearBits::DepthBit);
   if (m_trafficRenderer->HasRenderData())
   {
     m_trafficRenderer->RenderTraffic(modelView, m_currentZoomLevel, 1.0f /* opacity */,
-                                     make_ref(m_gpuProgramManager), m_frameValues);
+                                     context, make_ref(m_gpuProgramManager), m_frameValues);
   }
 }
 
@@ -1403,16 +1407,14 @@ void FrontendRenderer::RenderTransitBackground()
   if (!m_finishTexturesInitialization)
     return;
 
-  // TODO: Delete after refactoring of ScreenQuadRenderer.
-  GLFunctions::glDisable(gl_const::GLDepthTest);
-
   dp::TextureManager::ColorRegion region;
   m_texMng->GetColorRegion(df::GetColorConstant(kTransitBackgroundColor), region);
   CHECK(region.GetTexture() != nullptr, ("Texture manager is not initialized"));
-  //if (!m_transitBackground->IsInitialized())
+  if (!m_transitBackground->IsInitialized())
     m_transitBackground->SetTextureRect(region.GetTexRect());
-  m_transitBackground->RenderTexture(make_ref(m_gpuProgramManager),
-                                     static_cast<uint32_t>(region.GetTexture()->GetID()), 1.0f);
+
+  auto context = make_ref(m_contextFactory->GetDrawContext());
+  m_transitBackground->RenderTexture(context, make_ref(m_gpuProgramManager), region.GetTexture(), 1.0f);
 }
 
 void FrontendRenderer::RenderRouteLayer(ScreenBase const & modelView)
@@ -1420,9 +1422,10 @@ void FrontendRenderer::RenderRouteLayer(ScreenBase const & modelView)
   if (HasTransitRouteData())
     RenderTransitBackground();
 
-  m_contextFactory->GetDrawContext()->Clear(dp::ClearBits::DepthBit);
+  auto context = make_ref(m_contextFactory->GetDrawContext());
+  context->Clear(dp::ClearBits::DepthBit);
   m_routeRenderer->RenderRoute(modelView, m_trafficRenderer->HasRenderData(),
-                               make_ref(m_gpuProgramManager), m_frameValues);
+                               context, make_ref(m_gpuProgramManager), m_frameValues);
 }
 
 void FrontendRenderer::RenderUserMarksLayer(ScreenBase const & modelView, DepthLayer layerId)
@@ -1431,10 +1434,11 @@ void FrontendRenderer::RenderUserMarksLayer(ScreenBase const & modelView, DepthL
   if (renderGroups.empty())
     return;
 
-  m_contextFactory->GetDrawContext()->Clear(dp::ClearBits::DepthBit);
+  auto context = make_ref(m_contextFactory->GetDrawContext());
+  context->Clear(dp::ClearBits::DepthBit);
 
   for (drape_ptr<RenderGroup> & group : renderGroups)
-    RenderSingleGroup(modelView, make_ref(group));
+    RenderSingleGroup(context, modelView, make_ref(group));
 }
 
 void FrontendRenderer::RenderSearchMarksLayer(ScreenBase const & modelView)
@@ -1497,10 +1501,11 @@ void FrontendRenderer::PrepareBucket(dp::RenderState const & state, drape_ptr<dp
   bucket->GetBuffer()->Build(isPerspective ? program3d : program);
 }
 
-void FrontendRenderer::RenderSingleGroup(ScreenBase const & modelView, ref_ptr<BaseRenderGroup> group)
+void FrontendRenderer::RenderSingleGroup(ref_ptr<dp::GraphicsContext> context, ScreenBase const & modelView,
+                                         ref_ptr<BaseRenderGroup> group)
 {
   group->UpdateAnimation();
-  group->Render(modelView, make_ref(m_gpuProgramManager), m_frameValues);
+  group->Render(modelView, context, make_ref(m_gpuProgramManager), m_frameValues);
 }
 
 void FrontendRenderer::RefreshProjection(ScreenBase const & screen)
@@ -1834,6 +1839,7 @@ void FrontendRenderer::OnContextDestroy()
 
   m_selectObjectMessage.reset();
   m_overlayTree->SetSelectedFeature(FeatureID());
+  m_overlayTree->SetDebugRectRenderer(nullptr);
   m_overlayTree->Clear();
 
   m_guiRenderer.reset();
@@ -1851,7 +1857,7 @@ void FrontendRenderer::OnContextDestroy()
 
   m_transitBackground.reset();
 
-  dp::DebugRectRenderer::Instance().Destroy();
+  DebugRectRenderer::Instance()->Destroy();
 
   m_gpuProgramManager.reset();
 
@@ -1868,8 +1874,8 @@ void FrontendRenderer::OnContextCreate()
 {
   LOG(LINFO, ("On context create."));
 
-  auto context = m_contextFactory->GetDrawContext();
-  m_contextFactory->WaitForInitialization(context);
+  auto context = make_ref(m_contextFactory->GetDrawContext());
+  m_contextFactory->WaitForInitialization(context.get());
 
   context->MakeCurrent();
 
@@ -1885,17 +1891,12 @@ void FrontendRenderer::OnContextCreate()
 
   dp::AlphaBlendingState::Apply();
 
-  // TODO: think on redesigning DebugRectRenderer to eliminate functor.
-  dp::DebugRectRenderer::Instance().Init(m_gpuProgramManager->GetProgram(gpu::Program::DebugRect),
-    [this](ref_ptr<dp::GpuProgram> program, dp::Color const & color)
-  {
-    gpu::DebugRectProgramParams params;
-    params.m_color = glsl::ToVec4(color);
-    m_gpuProgramManager->GetParamsSetter()->Apply(program, params);
-  });
+  DebugRectRenderer::Instance()->Init(m_gpuProgramManager->GetProgram(gpu::Program::DebugRect),
+                                      m_gpuProgramManager->GetParamsSetter());
+  m_overlayTree->SetDebugRectRenderer(DebugRectRenderer::Instance());
 
 #ifdef RENDER_DEBUG_DISPLACEMENT
-  dp::DebugRectRenderer::Instance().SetEnabled(true);
+  DebugRectRenderer::Instance()->SetEnabled(true);
 #endif
 
   // Resources recovering.
@@ -1913,7 +1914,7 @@ void FrontendRenderer::OnContextCreate()
     m_postprocessRenderer->SetEffectEnabled(PostprocessRenderer::Antialiasing, true);
 #endif
 
-  m_buildingsFramebuffer = make_unique_dp<dp::Framebuffer>(gl_const::GLRGBA,
+  m_buildingsFramebuffer = make_unique_dp<dp::Framebuffer>(dp::TextureFormat::RGBA8,
                                                            true /* depthEnabled */,
                                                            false /* stencilEnabled */);
   m_buildingsFramebuffer->SetFramebufferFallback([this]()
diff --git a/drape_frontend/frontend_renderer.hpp b/drape_frontend/frontend_renderer.hpp
index e84866d2d9..3aa45cbaec 100755
--- a/drape_frontend/frontend_renderer.hpp
+++ b/drape_frontend/frontend_renderer.hpp
@@ -144,7 +144,8 @@ private:
   void OnResize(ScreenBase const & screen);
   void RenderScene(ScreenBase const & modelView, bool activeFrame);
   void PrepareBucket(dp::RenderState const & state, drape_ptr<dp::RenderBucket> & bucket);
-  void RenderSingleGroup(ScreenBase const & modelView, ref_ptr<BaseRenderGroup> group);
+  void RenderSingleGroup(ref_ptr<dp::GraphicsContext> context, ScreenBase const & modelView,
+                         ref_ptr<BaseRenderGroup> group);
   void RefreshProjection(ScreenBase const & screen);
   void RefreshZScale(ScreenBase const & screen);
   void RefreshPivotTransform(ScreenBase const & screen);
diff --git a/drape_frontend/gps_track_renderer.cpp b/drape_frontend/gps_track_renderer.cpp
index b6a44ca690..d5e8dec3b1 100644
--- a/drape_frontend/gps_track_renderer.cpp
+++ b/drape_frontend/gps_track_renderer.cpp
@@ -190,6 +190,7 @@ dp::Color GpsTrackRenderer::GetColorBySpeed(double speed) const
 }
 
 void GpsTrackRenderer::RenderTrack(ScreenBase const & screen, int zoomLevel,
+                                   ref_ptr<dp::GraphicsContext> context,
                                    ref_ptr<gpu::ProgramManager> mng,
                                    FrameValues const & frameValues)
 {
@@ -309,7 +310,7 @@ void GpsTrackRenderer::RenderTrack(ScreenBase const & screen, int zoomLevel,
 
   ASSERT_GREATER(m_renderData.size(), 0, ());
   dp::RenderState const & state = m_renderData.front()->m_state;
-  dp::ApplyState(state, program);
+  dp::ApplyState(state, context, program);
   mng->GetParamsSetter()->Apply(program, params);
 
   for (size_t i = 0; i < m_renderData.size(); i++)
diff --git a/drape_frontend/gps_track_renderer.hpp b/drape_frontend/gps_track_renderer.hpp
index e14b40fb49..64489f5b23 100644
--- a/drape_frontend/gps_track_renderer.hpp
+++ b/drape_frontend/gps_track_renderer.hpp
@@ -6,6 +6,7 @@
 
 #include "shaders/program_manager.hpp"
 
+#include "drape/graphics_context.hpp"
 #include "drape/pointers.hpp"
 
 #include "geometry/screenbase.hpp"
@@ -30,6 +31,7 @@ public:
                     std::vector<uint32_t> const & toRemove);
 
   void RenderTrack(ScreenBase const & screen, int zoomLevel,
+                   ref_ptr<dp::GraphicsContext> context,
                    ref_ptr<gpu::ProgramManager> mng,
                    FrameValues const & frameValues);
 
diff --git a/drape_frontend/gui/layer_render.cpp b/drape_frontend/gui/layer_render.cpp
index efec86c010..9186a28a30 100644
--- a/drape_frontend/gui/layer_render.cpp
+++ b/drape_frontend/gui/layer_render.cpp
@@ -40,7 +40,7 @@ void LayerRenderer::Build(ref_ptr<gpu::ProgramManager> mng)
     r.second->Build(mng);
 }
 
-void LayerRenderer::Render(ref_ptr<gpu::ProgramManager> mng, bool routingActive,
+void LayerRenderer::Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, bool routingActive,
                            ScreenBase const & screen)
 {
   if (HasWidget(gui::WIDGET_RULER))
@@ -54,7 +54,7 @@ void LayerRenderer::Render(ref_ptr<gpu::ProgramManager> mng, bool routingActive,
     if (routingActive && (r.first == gui::WIDGET_COMPASS || r.first == gui::WIDGET_RULER))
       continue;
 
-    r.second->Render(screen, mng);
+    r.second->Render(screen, context, mng);
   }
 }
 
diff --git a/drape_frontend/gui/layer_render.hpp b/drape_frontend/gui/layer_render.hpp
index 2d4c4d94ac..7de93972ac 100644
--- a/drape_frontend/gui/layer_render.hpp
+++ b/drape_frontend/gui/layer_render.hpp
@@ -27,7 +27,7 @@ public:
   ~LayerRenderer();
 
   void Build(ref_ptr<gpu::ProgramManager> mng);
-  void Render(ref_ptr<gpu::ProgramManager> mng, bool routingActive,
+  void Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, bool routingActive,
               ScreenBase const & screen);
   void Merge(ref_ptr<LayerRenderer> other);
   void SetLayout(gui::TWidgetsLayoutInfo const & info);
diff --git a/drape_frontend/gui/shape.cpp b/drape_frontend/gui/shape.cpp
index 983b54ed98..d1cf7f5c85 100644
--- a/drape_frontend/gui/shape.cpp
+++ b/drape_frontend/gui/shape.cpp
@@ -87,7 +87,8 @@ void ShapeRenderer::Build(ref_ptr<gpu::ProgramManager> mng)
   });
 }
 
-void ShapeRenderer::Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng)
+void ShapeRenderer::Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+                           ref_ptr<gpu::ProgramManager> mng)
 {
   std::array<float, 16> m = {};
   m2::RectD const & pxRect = screen.PixelRectIn3d();
@@ -95,7 +96,7 @@ void ShapeRenderer::Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManage
                      static_cast<float>(pxRect.SizeY()), 0.0f);
   glsl::mat4 const projection = glsl::make_mat4(m.data());
 
-  ForEachShapeInfo([&projection, &screen, mng](ShapeControl::ShapeInfo & info) mutable
+  ForEachShapeInfo([&projection, &screen, context, mng](ShapeControl::ShapeInfo & info) mutable
   {
     if (!info.m_handle->Update(screen))
       return;
@@ -105,7 +106,7 @@ void ShapeRenderer::Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManage
 
     ref_ptr<dp::GpuProgram> prg = mng->GetProgram(info.m_state.GetProgram<gpu::Program>());
     prg->Bind();
-    dp::ApplyState(info.m_state, prg);
+    dp::ApplyState(info.m_state, context, prg);
 
     auto params = info.m_handle->GetParams();
     params.m_projection = projection;
diff --git a/drape_frontend/gui/shape.hpp b/drape_frontend/gui/shape.hpp
index 228943a3e3..22845e998d 100644
--- a/drape_frontend/gui/shape.hpp
+++ b/drape_frontend/gui/shape.hpp
@@ -89,7 +89,7 @@ public:
   ~ShapeRenderer();
 
   void Build(ref_ptr<gpu::ProgramManager> mng);
-  void Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng);
+  void Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng);
   void AddShape(dp::RenderState const & state, drape_ptr<dp::RenderBucket> && bucket);
   void AddShapeControl(ShapeControl && control);
 
diff --git a/drape_frontend/line_shape.cpp b/drape_frontend/line_shape.cpp
index 8f71f0ce36..58df9b4532 100644
--- a/drape_frontend/line_shape.cpp
+++ b/drape_frontend/line_shape.cpp
@@ -212,7 +212,7 @@ public:
     auto state = CreateRenderState(gpu::Program::CapJoin, m_params.m_depthLayer);
     state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
     state.SetColorTexture(m_params.m_color.GetTexture());
-    state.SetDepthFunction(dp::DepthFunction::Less);
+    state.SetDepthFunction(dp::TestFunction::Less);
     return state;
   }
 
diff --git a/drape_frontend/my_position.cpp b/drape_frontend/my_position.cpp
index ee678588e7..13705af15d 100644
--- a/drape_frontend/my_position.cpp
+++ b/drape_frontend/my_position.cpp
@@ -98,6 +98,7 @@ void MyPosition::SetPositionObsolete(bool obsolete)
 }
 
 void MyPosition::RenderAccuracy(ScreenBase const & screen, int zoomLevel,
+                                ref_ptr<dp::GraphicsContext> context,
                                 ref_ptr<gpu::ProgramManager> mng,
                                 FrameValues const & frameValues)
 {
@@ -115,10 +116,11 @@ void MyPosition::RenderAccuracy(ScreenBase const & screen, int zoomLevel,
     MapShape::ConvertToLocal(m2::PointD(m_position), key.GetGlobalRect().Center(), kShapeCoordScalar));
   params.m_position = glsl::vec3(pos.x, pos.y, 0.0f);
   params.m_accuracy = pixelAccuracy;
-  RenderPart(mng, params, MyPositionAccuracy);
+  RenderPart(context, mng, params, MyPositionAccuracy);
 }
 
 void MyPosition::RenderMyPosition(ScreenBase const & screen, int zoomLevel,
+                                  ref_ptr<dp::GraphicsContext> context,
                                   ref_ptr<gpu::ProgramManager> mng,
                                   FrameValues const & frameValues)
 {
@@ -126,7 +128,7 @@ void MyPosition::RenderMyPosition(ScreenBase const & screen, int zoomLevel,
   {
     m_arrow3d.SetPosition(m2::PointD(m_position));
     m_arrow3d.SetAzimuth(m_azimuth);
-    m_arrow3d.Render(screen, mng, m_isRoutingMode);
+    m_arrow3d.Render(screen, context, mng, m_isRoutingMode);
   }
   else
   {
@@ -140,7 +142,7 @@ void MyPosition::RenderMyPosition(ScreenBase const & screen, int zoomLevel,
       MapShape::ConvertToLocal(m2::PointD(m_position), key.GetGlobalRect().Center(), kShapeCoordScalar));
     params.m_position = glsl::vec3(pos.x, pos.y, dp::depth::kMyPositionMarkDepth);
     params.m_azimut = -(m_azimuth + static_cast<float>(screen.GetAngle()));
-    RenderPart(mng, params, MyPositionPoint);
+    RenderPart(context, mng, params, MyPositionPoint);
   }
 }
 
@@ -244,11 +246,11 @@ void MyPosition::CachePointPosition(ref_ptr<dp::TextureManager> mng)
   }
 }
 
-void MyPosition::RenderPart(ref_ptr<gpu::ProgramManager> mng,
+void MyPosition::RenderPart(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
                             gpu::ShapesProgramParams const & params,
                             EMyPositionPart part)
 {
   TPart const & p = m_parts[part];
-  m_nodes[p.second].Render(mng, params, p.first);
+  m_nodes[p.second].Render(context, mng, params, p.first);
 }
 }  // namespace df
diff --git a/drape_frontend/my_position.hpp b/drape_frontend/my_position.hpp
index 164548d98b..09264eb5a6 100644
--- a/drape_frontend/my_position.hpp
+++ b/drape_frontend/my_position.hpp
@@ -32,10 +32,12 @@ public:
   void SetPositionObsolete(bool obsolete);
 
   void RenderAccuracy(ScreenBase const & screen, int zoomLevel,
+                      ref_ptr<dp::GraphicsContext> context,
                       ref_ptr<gpu::ProgramManager> mng,
                       FrameValues const & frameValues);
 
   void RenderMyPosition(ScreenBase const & screen, int zoomLevel,
+                        ref_ptr<dp::GraphicsContext> context,
                         ref_ptr<gpu::ProgramManager> mng,
                         FrameValues const & frameValues);
 
@@ -50,7 +52,7 @@ private:
     MyPositionPoint = 1,
   };
 
-  void RenderPart(ref_ptr<gpu::ProgramManager> mng,
+  void RenderPart(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
                   gpu::ShapesProgramParams const & params,
                   EMyPositionPart part);
 
diff --git a/drape_frontend/my_position_controller.cpp b/drape_frontend/my_position_controller.cpp
index 602a65a657..cc40be1192 100644
--- a/drape_frontend/my_position_controller.cpp
+++ b/drape_frontend/my_position_controller.cpp
@@ -610,6 +610,7 @@ bool MyPositionController::UpdateViewportWithAutoZoom()
 }
 
 void MyPositionController::Render(ScreenBase const & screen, int zoomLevel,
+                                  ref_ptr<dp::GraphicsContext> context,
                                   ref_ptr<gpu::ProgramManager> mng,
                                   FrameValues const & frameValues)
 {
@@ -639,8 +640,8 @@ void MyPositionController::Render(ScreenBase const & screen, int zoomLevel,
     m_shape->SetAccuracy(static_cast<float>(m_errorRadius));
     m_shape->SetRoutingMode(IsInRouting());
 
-    m_shape->RenderAccuracy(screen, zoomLevel, mng, frameValues);
-    m_shape->RenderMyPosition(screen, zoomLevel, mng, frameValues);
+    m_shape->RenderAccuracy(screen, zoomLevel, context, mng, frameValues);
+    m_shape->RenderMyPosition(screen, zoomLevel, context, mng, frameValues);
   }
 }
 
diff --git a/drape_frontend/my_position_controller.hpp b/drape_frontend/my_position_controller.hpp
index 63cd790ee3..75369ff490 100644
--- a/drape_frontend/my_position_controller.hpp
+++ b/drape_frontend/my_position_controller.hpp
@@ -119,8 +119,8 @@ public:
   void OnLocationUpdate(location::GpsInfo const & info, bool isNavigable, ScreenBase const & screen);
   void OnCompassUpdate(location::CompassInfo const & info, ScreenBase const & screen);
 
-  void Render(ScreenBase const & screen, int zoomLevel, ref_ptr<gpu::ProgramManager> mng,
-              FrameValues const & frameValues);
+  void Render(ScreenBase const & screen, int zoomLevel, ref_ptr<dp::GraphicsContext> context,
+              ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
 
   bool IsRotationAvailable() const { return m_isDirectionAssigned; }
   bool IsInRouting() const { return m_isInRouting; }
diff --git a/drape_frontend/postprocess_renderer.cpp b/drape_frontend/postprocess_renderer.cpp
index f1279174d1..76c465a623 100644
--- a/drape_frontend/postprocess_renderer.cpp
+++ b/drape_frontend/postprocess_renderer.cpp
@@ -4,8 +4,11 @@
 
 #include "shaders/program_manager.hpp"
 
-#include "drape/glfunctions.hpp"
+#include "drape/glsl_types.hpp"
+#include "drape/graphics_context.hpp"
+#include "drape/mesh_object.hpp"
 #include "drape/texture_manager.hpp"
+#include "drape/render_state.hpp"
 
 #include "base/assert.hpp"
 
@@ -13,168 +16,97 @@ namespace df
 {
 namespace
 {
-class SMAABaseRendererContext : public RendererContext
+class SMAABaseRenderParams
 {
-protected:
-  void ApplyParameters(ref_ptr<gpu::ProgramManager> mng, ref_ptr<dp::GpuProgram> prg)
+public:
+  SMAABaseRenderParams(gpu::Program program)
+    : m_state(CreateRenderState(program, DepthLayer::GeometryLayer))
   {
-    mng->GetParamsSetter()->Apply(prg, m_params);
+    m_state.SetDepthTestEnabled(false);
+    m_state.SetBlending(dp::Blending(false));
   }
 
+  dp::RenderState const & GetRenderState() const { return m_state; }
+  gpu::SMAAProgramParams const & GetProgramParams() const { return m_params; }
+
+protected:
+  dp::RenderState m_state;
   gpu::SMAAProgramParams m_params;
 };
 
-class EdgesRendererContext : public SMAABaseRendererContext
+class EdgesRenderParams : public SMAABaseRenderParams
 {
+  using TBase = SMAABaseRenderParams;
 public:
-  gpu::Program GetGpuProgram() const override { return gpu::Program::SmaaEdges; }
+  EdgesRenderParams(): TBase(gpu::Program::SmaaEdges) {}
 
-  void PreRender(ref_ptr<gpu::ProgramManager> mng) override
+  void SetParams(ref_ptr<dp::Texture> texture, uint32_t width, uint32_t height)
   {
-    auto prg = mng->GetProgram(GetGpuProgram());
+    m_state.SetTexture("u_colorTex", texture);
 
-    GLFunctions::glClear(gl_const::GLColorBit);
-
-    BindTexture(m_textureId, prg, "u_colorTex", 0 /* slotIndex */,
-                gl_const::GLLinear, gl_const::GLClampToEdge);
-    ApplyParameters(mng, prg);
-
-    GLFunctions::glDisable(gl_const::GLDepthTest);
-    GLFunctions::glDisable(gl_const::GLBlending);
-  }
-
-  void SetParams(uint32_t textureId, uint32_t width, uint32_t height)
-  {
-    m_textureId = textureId;
     m_params.m_framebufferMetrics = glsl::vec4(1.0f / width, 1.0f / height,
                                                static_cast<float>(width),
                                                static_cast<float>(height));
   }
-
-protected:
-  uint32_t m_textureId = 0;
 };
 
-class BlendingWeightRendererContext : public SMAABaseRendererContext
+class BlendingWeightRenderParams : public SMAABaseRenderParams
 {
+  using TBase = SMAABaseRenderParams;
 public:
-  gpu::Program GetGpuProgram() const override { return gpu::Program::SmaaBlendingWeight; }
+  BlendingWeightRenderParams() : TBase(gpu::Program::SmaaBlendingWeight) {}
 
-  void PreRender(ref_ptr<gpu::ProgramManager> mng) override
+  void SetParams(ref_ptr<dp::Texture> edgesTexture, ref_ptr<dp::Texture> areaTexture,
+                 ref_ptr<dp::Texture> searchTexture, uint32_t width, uint32_t height)
   {
-    auto prg = mng->GetProgram(GetGpuProgram());
-
-    GLFunctions::glClear(gl_const::GLColorBit);
-
-    BindTexture(m_edgesTextureId, prg, "u_colorTex", 0 /* slotIndex */,
-                gl_const::GLLinear, gl_const::GLClampToEdge);
-    BindTexture(m_areaTextureId, prg, "u_smaaArea", 1 /* slotIndex */,
-                gl_const::GLLinear, gl_const::GLClampToEdge);
-    BindTexture(m_searchTextureId, prg, "u_smaaSearch", 2 /* slotIndex */,
-                gl_const::GLLinear, gl_const::GLClampToEdge);
-    ApplyParameters(mng, prg);
+    m_state.SetTexture("u_colorTex", edgesTexture);
+    m_state.SetTexture("u_smaaArea", areaTexture);
+    m_state.SetTexture("u_smaaSearch", searchTexture);
 
-    GLFunctions::glDisable(gl_const::GLDepthTest);
-    GLFunctions::glDisable(gl_const::GLBlending);
-  }
-
-  void PostRender() override
-  {
-    GLFunctions::glActiveTexture(gl_const::GLTexture0 + 2);
-    GLFunctions::glBindTexture(0);
-  }
-
-  void SetParams(uint32_t edgesTextureId, uint32_t areaTextureId, uint32_t searchTextureId,
-                 uint32_t width, uint32_t height)
-  {
-    m_edgesTextureId = edgesTextureId;
-    m_areaTextureId = areaTextureId;
-    m_searchTextureId = searchTextureId;
     m_params.m_framebufferMetrics = glsl::vec4(1.0f / width, 1.0f / height,
                                                static_cast<float>(width),
                                                static_cast<float>(height));
   }
-
-private:
-  uint32_t m_edgesTextureId = 0;
-  uint32_t m_areaTextureId = 0;
-  uint32_t m_searchTextureId = 0;
 };
 
-class SMAAFinalRendererContext : public SMAABaseRendererContext
+class SMAAFinalRendeParams : public SMAABaseRenderParams
 {
+  using TBase = SMAABaseRenderParams;
 public:
-  gpu::Program GetGpuProgram() const override { return gpu::Program::SmaaFinal; }
-
-  void PreRender(ref_ptr<gpu::ProgramManager> mng) override
-  {
-    auto prg = mng->GetProgram(GetGpuProgram());
-
-    GLFunctions::glClear(gl_const::GLColorBit);
+  SMAAFinalRendeParams(): TBase(gpu::Program::SmaaFinal) {}
 
-    BindTexture(m_colorTextureId, prg, "u_colorTex", 0 /* slotIndex */,
-                gl_const::GLLinear, gl_const::GLClampToEdge);
-    BindTexture(m_blendingWeightTextureId, prg, "u_blendingWeightTex", 1 /* slotIndex */,
-                gl_const::GLLinear, gl_const::GLClampToEdge);
-    ApplyParameters(mng, prg);
-
-    GLFunctions::glDisable(gl_const::GLDepthTest);
-    GLFunctions::glDisable(gl_const::GLBlending);
-  }
-
-  void PostRender() override
+  void SetParams(ref_ptr<dp::Texture> colorTexture, ref_ptr<dp::Texture> blendingWeightTexture,
+                 uint32_t width, uint32_t height)
   {
-    GLFunctions::glActiveTexture(gl_const::GLTexture0 + 1);
-    GLFunctions::glBindTexture(0);
-    GLFunctions::glActiveTexture(gl_const::GLTexture0);
-    GLFunctions::glBindTexture(0);
-  }
+    m_state.SetTexture("u_colorTex", colorTexture);
+    m_state.SetTexture("u_blendingWeightTex", blendingWeightTexture);
 
-  void SetParams(uint32_t colorTextureId, uint32_t blendingWeightTextureId, uint32_t width,
-                 uint32_t height)
-  {
-    m_colorTextureId = colorTextureId;
-    m_blendingWeightTextureId = blendingWeightTextureId;
     m_params.m_framebufferMetrics = glsl::vec4(1.0f / width, 1.0f / height,
                                                static_cast<float>(width),
                                                static_cast<float>(height));
   }
-
-private:
-  uint32_t m_colorTextureId = 0;
-  uint32_t m_blendingWeightTextureId = 0;
 };
 
-class DefaultScreenQuadContext : public RendererContext
+class DefaultScreenQuadRenderParams
 {
 public:
-  gpu::Program GetGpuProgram() const override { return gpu::Program::ScreenQuad; }
-
-  void PreRender(ref_ptr<gpu::ProgramManager> mng) override
+  DefaultScreenQuadRenderParams()
+    : m_state(CreateRenderState(gpu::Program::ScreenQuad, DepthLayer::GeometryLayer))
   {
-    auto prg = mng->GetProgram(GetGpuProgram());
-
-    BindTexture(m_textureId, prg, "u_colorTex", 0 /* slotIndex */,
-                gl_const::GLLinear, gl_const::GLClampToEdge);
-
-    mng->GetParamsSetter()->Apply(prg, m_params);
-
-    GLFunctions::glDisable(gl_const::GLDepthTest);
-    GLFunctions::glDisable(gl_const::GLBlending);
+    m_state.SetDepthTestEnabled(false);
+    m_state.SetBlending(dp::Blending(false));
   }
 
-  void PostRender() override
+  void SetParams(ref_ptr<dp::Texture> texture)
   {
-    GLFunctions::glBindTexture(0);
+    m_state.SetTexture("u_colorTex", texture);
   }
 
-  void SetParams(uint32_t textureId)
-  {
-    m_textureId = textureId;
-  }
+  dp::RenderState const & GetRenderState() const { return m_state; }
+  gpu::ScreenQuadProgramParams const & GetProgramParams() const { return m_params; }
 
 private:
-  uint32_t m_textureId = 0;
+  dp::RenderState m_state;
   gpu::ScreenQuadProgramParams m_params;
 };
 
@@ -182,11 +114,11 @@ void InitFramebuffer(drape_ptr<dp::Framebuffer> & framebuffer, uint32_t width, u
                      bool depthEnabled, bool stencilEnabled)
 {
   if (framebuffer == nullptr)
-    framebuffer = make_unique_dp<dp::Framebuffer>(gl_const::GLRGBA, depthEnabled, stencilEnabled);
+    framebuffer = make_unique_dp<dp::Framebuffer>(dp::TextureFormat::RGBA8, depthEnabled, stencilEnabled);
   framebuffer->SetSize(width, height);
 }
 
-void InitFramebuffer(drape_ptr<dp::Framebuffer> & framebuffer, uint32_t colorFormat,
+void InitFramebuffer(drape_ptr<dp::Framebuffer> & framebuffer, dp::TextureFormat colorFormat,
                      ref_ptr<dp::Framebuffer::DepthStencil> depthStencilRef,
                      uint32_t width, uint32_t height)
 {
@@ -202,13 +134,6 @@ bool IsSupported(drape_ptr<dp::Framebuffer> const & framebuffer)
 }
 }  // namespace
 
-PostprocessRenderer::PostprocessRenderer()
-  : m_edgesRendererContext(make_unique_dp<EdgesRendererContext>())
-  , m_bwRendererContext(make_unique_dp<BlendingWeightRendererContext>())
-  , m_smaaFinalRendererContext(make_unique_dp<SMAAFinalRendererContext>())
-  , m_defaultScreenQuadContext(make_unique_dp<DefaultScreenQuadContext>())
-{}
-
 PostprocessRenderer::~PostprocessRenderer()
 {
   ClearGLDependentResources();
@@ -297,7 +222,7 @@ bool PostprocessRenderer::CanRenderAntialiasing() const
          m_staticTextures->m_smaaSearchTexture->GetID() != 0;
 }
 
-bool PostprocessRenderer::BeginFrame(bool activeFrame)
+bool PostprocessRenderer::BeginFrame(ref_ptr<dp::GraphicsContext> context, bool activeFrame)
 {
   if (!IsEnabled())
   {
@@ -310,13 +235,13 @@ bool PostprocessRenderer::BeginFrame(bool activeFrame)
     m_mainFramebuffer->Enable();
 
   if (m_frameStarted && CanRenderAntialiasing())
-    GLFunctions::glDisable(gl_const::GLStencilTest);
+    context->SetStencilTestEnabled(false);
 
   m_isMainFramebufferRendered = true;
   return m_frameStarted;
 }
 
-bool PostprocessRenderer::EndFrame(ref_ptr<gpu::ProgramManager> gpuProgramManager)
+bool PostprocessRenderer::EndFrame(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> gpuProgramManager)
 {
   if (!IsEnabled())
     return true;
@@ -330,51 +255,64 @@ bool PostprocessRenderer::EndFrame(ref_ptr<gpu::ProgramManager> gpuProgramManage
     ASSERT(m_staticTextures->m_smaaSearchTexture != nullptr, ());
     ASSERT_GREATER(m_staticTextures->m_smaaSearchTexture->GetID(), 0, ());
 
-    GLFunctions::glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-    GLFunctions::glEnable(gl_const::GLStencilTest);
+    context->SetClearColor(dp::Color::Transparent());
+    context->SetStencilTestEnabled(true);
 
     // Render edges to texture.
     {
       m_edgesFramebuffer->Enable();
 
-      GLFunctions::glStencilFuncSeparate(gl_const::GLFrontAndBack, gl_const::GLNotEqual, 1, 1);
-      GLFunctions::glStencilOpSeparate(gl_const::GLFrontAndBack, gl_const::GLZero,
-                                       gl_const::GLZero, gl_const::GLReplace);
+      context->Clear(dp::ClearBits::ColorBit);
+
+      context->SetStencilFunction(dp::StencilFace::FrontAndBack, dp::TestFunction::NotEqual);
+      context->SetStencilActions(dp::StencilFace::FrontAndBack, dp::StencilAction::Zero,
+                                 dp::StencilAction::Zero, dp::StencilAction::Replace);
 
-      ASSERT(dynamic_cast<EdgesRendererContext *>(m_edgesRendererContext.get()) != nullptr, ());
-      auto context = static_cast<EdgesRendererContext *>(m_edgesRendererContext.get());
-      context->SetParams(m_mainFramebuffer->GetTextureId(), m_width, m_height);
-      m_screenQuadRenderer->Render(gpuProgramManager, make_ref(m_edgesRendererContext));
+      EdgesRenderParams params;
+      params.SetParams(m_mainFramebuffer->GetTexture(), m_width, m_height);
+
+      auto program = gpuProgramManager->GetProgram(params.GetRenderState().GetProgram<gpu::Program>());
+      m_screenQuadRenderer->Render(context, program, params.GetRenderState(), gpuProgramManager->GetParamsSetter(),
+                                   params.GetProgramParams());
     }
 
     // Render blending weight to texture.
     {
       m_blendingWeightFramebuffer->Enable();
 
-      GLFunctions::glStencilFuncSeparate(gl_const::GLFrontAndBack, gl_const::GLEqual, 1, 1);
-      GLFunctions::glStencilOpSeparate(gl_const::GLFrontAndBack, gl_const::GLKeep,
-                                       gl_const::GLKeep, gl_const::GLKeep);
-
-      ASSERT(dynamic_cast<BlendingWeightRendererContext *>(m_bwRendererContext.get()) != nullptr, ());
-      auto context = static_cast<BlendingWeightRendererContext *>(m_bwRendererContext.get());
-      context->SetParams(m_edgesFramebuffer->GetTextureId(),
-                         m_staticTextures->m_smaaAreaTexture->GetID(),
-                         m_staticTextures->m_smaaSearchTexture->GetID(),
-                         m_width, m_height);
-      m_screenQuadRenderer->Render(gpuProgramManager, make_ref(m_bwRendererContext));
+      context->Clear(dp::ClearBits::ColorBit);
+
+      context->SetStencilFunction(dp::StencilFace::FrontAndBack, dp::TestFunction::Equal);
+      context->SetStencilActions(dp::StencilFace::FrontAndBack, dp::StencilAction::Keep,
+                                 dp::StencilAction::Keep, dp::StencilAction::Keep);
+
+      BlendingWeightRenderParams params;
+      params.SetParams(m_edgesFramebuffer->GetTexture(),
+                       m_staticTextures->m_smaaAreaTexture,
+                       m_staticTextures->m_smaaSearchTexture,
+                       m_width, m_height);
+
+      auto program = gpuProgramManager->GetProgram(params.GetRenderState().GetProgram<gpu::Program>());
+      m_screenQuadRenderer->Render(context, program, params.GetRenderState(), gpuProgramManager->GetParamsSetter(),
+                                   params.GetProgramParams());
     }
 
     // SMAA final pass.
-    GLFunctions::glDisable(gl_const::GLStencilTest);
+    context->SetStencilTestEnabled(false);
     {
       m_smaaFramebuffer->Enable();
 
-      ASSERT(dynamic_cast<SMAAFinalRendererContext *>(m_smaaFinalRendererContext.get()) != nullptr, ());
-      auto context = static_cast<SMAAFinalRendererContext *>(m_smaaFinalRendererContext.get());
-      context->SetParams(m_mainFramebuffer->GetTextureId(),
-                         m_blendingWeightFramebuffer->GetTextureId(),
-                         m_width, m_height);
-      m_screenQuadRenderer->Render(gpuProgramManager, make_ref(m_smaaFinalRendererContext));
+      context->Clear(dp::ClearBits::ColorBit);
+
+      SMAAFinalRendeParams params;
+      params.SetParams(m_mainFramebuffer->GetTexture(),
+                       m_blendingWeightFramebuffer->GetTexture(),
+                       m_width, m_height);
+
+      auto program = gpuProgramManager->GetProgram(params.GetRenderState().GetProgram<gpu::Program>());
+      m_screenQuadRenderer->Render(context, program, params.GetRenderState(), gpuProgramManager->GetParamsSetter(),
+                                   params.GetProgramParams());
+
       m_isSmaaFramebufferRendered = true;
     }
   }
@@ -389,31 +327,34 @@ bool PostprocessRenderer::EndFrame(ref_ptr<gpu::ProgramManager> gpuProgramManage
   bool m_wasRendered = false;
   if (m_framebufferFallback())
   {
-    ASSERT(dynamic_cast<DefaultScreenQuadContext *>(m_defaultScreenQuadContext.get()) != nullptr, ());
-    auto context = static_cast<DefaultScreenQuadContext *>(m_defaultScreenQuadContext.get());
-    context->SetParams(finalFramebuffer->GetTextureId());
-    m_screenQuadRenderer->Render(gpuProgramManager, make_ref(m_defaultScreenQuadContext));
+    DefaultScreenQuadRenderParams params;
+    params.SetParams(finalFramebuffer->GetTexture());
+
+    auto program = gpuProgramManager->GetProgram(params.GetRenderState().GetProgram<gpu::Program>());
+    m_screenQuadRenderer->Render(context, program, params.GetRenderState(), gpuProgramManager->GetParamsSetter(),
+                                 params.GetProgramParams());
+
     m_wasRendered = true;
   }
   m_frameStarted = false;
   return m_wasRendered;
 }
 
-void PostprocessRenderer::EnableWritingToStencil() const
+void PostprocessRenderer::EnableWritingToStencil(ref_ptr<dp::GraphicsContext> context) const
 {
   if (!m_frameStarted || !CanRenderAntialiasing())
     return;
-  GLFunctions::glEnable(gl_const::GLStencilTest);
-  GLFunctions::glStencilFuncSeparate(gl_const::GLFrontAndBack, gl_const::GLAlways, 1, 1);
-  GLFunctions::glStencilOpSeparate(gl_const::GLFrontAndBack, gl_const::GLKeep,
-                                   gl_const::GLKeep, gl_const::GLReplace);
+  context->SetStencilTestEnabled(true);
+  context->SetStencilFunction(dp::StencilFace::FrontAndBack, dp::TestFunction::Always);
+  context->SetStencilActions(dp::StencilFace::FrontAndBack, dp::StencilAction::Keep,
+                             dp::StencilAction::Keep, dp::StencilAction::Replace);
 }
 
-void PostprocessRenderer::DisableWritingToStencil() const
+void PostprocessRenderer::DisableWritingToStencil(ref_ptr<dp::GraphicsContext> context) const
 {
   if (!m_frameStarted || !CanRenderAntialiasing())
     return;
-  GLFunctions::glDisable(gl_const::GLStencilTest);
+  context->SetStencilTestEnabled(false);
 }
 
 void PostprocessRenderer::UpdateFramebuffers(uint32_t width, uint32_t height)
@@ -431,13 +372,13 @@ void PostprocessRenderer::UpdateFramebuffers(uint32_t width, uint32_t height)
   {
     CHECK(m_apiVersion != dp::ApiVersion::OpenGLES2, ());
 
-    InitFramebuffer(m_edgesFramebuffer, gl_const::GLRedGreen,
+    InitFramebuffer(m_edgesFramebuffer, dp::TextureFormat::RedGreen,
                     m_mainFramebuffer->GetDepthStencilRef(),
                     width, height);
-    InitFramebuffer(m_blendingWeightFramebuffer, gl_const::GLRGBA,
+    InitFramebuffer(m_blendingWeightFramebuffer, dp::TextureFormat::RGBA8,
                     m_mainFramebuffer->GetDepthStencilRef(),
                     width, height);
-    InitFramebuffer(m_smaaFramebuffer, gl_const::GLRGBA,
+    InitFramebuffer(m_smaaFramebuffer, dp::TextureFormat::RGBA8,
                     m_mainFramebuffer->GetDepthStencilRef(),
                     width, height);
   }
@@ -481,15 +422,16 @@ void PostprocessRenderer::OnChangedRouteFollowingMode(bool isRouteFollowingActiv
   }
 }
 
-StencilWriterGuard::StencilWriterGuard(ref_ptr<PostprocessRenderer> renderer)
+StencilWriterGuard::StencilWriterGuard(ref_ptr<PostprocessRenderer> renderer, ref_ptr<dp::GraphicsContext> context)
   : m_renderer(renderer)
+  , m_context(context)
 {
   ASSERT(m_renderer != nullptr, ());
-  m_renderer->EnableWritingToStencil();
+  m_renderer->EnableWritingToStencil(m_context);
 }
 
 StencilWriterGuard::~StencilWriterGuard()
 {
-  m_renderer->DisableWritingToStencil();
+  m_renderer->DisableWritingToStencil(m_context);
 }
 }  // namespace df
diff --git a/drape_frontend/postprocess_renderer.hpp b/drape_frontend/postprocess_renderer.hpp
index c717e9f788..4bf46f20f5 100644
--- a/drape_frontend/postprocess_renderer.hpp
+++ b/drape_frontend/postprocess_renderer.hpp
@@ -3,11 +3,16 @@
 #include "drape/drape_global.hpp"
 #include "drape/framebuffer.hpp"
 #include "drape/pointers.hpp"
+#include "drape/render_state.hpp"
+
+#include "shaders/program_params.hpp"
 
 #include <cstdint>
 
 namespace dp
 {
+class GraphicsContext;
+class RenderParamsHolder;
 class Texture;
 }  // namespace dp
 
@@ -19,7 +24,6 @@ class ProgramManager;
 namespace df
 {
 class ScreenQuadRenderer;
-class RendererContext;
 
 struct PostprocessStaticTextures
 {
@@ -35,7 +39,7 @@ public:
     Antialiasing = 1
   };
 
-  PostprocessRenderer();
+  PostprocessRenderer() = default;
   ~PostprocessRenderer();
 
   void Init(dp::ApiVersion apiVersion, dp::FramebufferFallback && fallback);
@@ -50,11 +54,11 @@ public:
   bool OnFramebufferFallback();
   void OnChangedRouteFollowingMode(bool isRouteFollowingActive);
 
-  bool BeginFrame(bool activeFrame);
-  bool EndFrame(ref_ptr<gpu::ProgramManager> gpuProgramManager);
+  bool BeginFrame(ref_ptr<dp::GraphicsContext> context, bool activeFrame);
+  bool EndFrame(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> gpuProgramManager);
 
-  void EnableWritingToStencil() const;
-  void DisableWritingToStencil() const;
+  void EnableWritingToStencil(ref_ptr<dp::GraphicsContext> context) const;
+  void DisableWritingToStencil(ref_ptr<dp::GraphicsContext> context) const;
 
 private:
   void UpdateFramebuffers(uint32_t width, uint32_t height);
@@ -76,11 +80,6 @@ private:
   drape_ptr<dp::Framebuffer> m_smaaFramebuffer;
   bool m_isSmaaFramebufferRendered = false;
 
-  drape_ptr<RendererContext> m_edgesRendererContext;
-  drape_ptr<RendererContext> m_bwRendererContext;
-  drape_ptr<RendererContext> m_smaaFinalRendererContext;
-  drape_ptr<RendererContext> m_defaultScreenQuadContext;
-
   bool m_frameStarted = false;
   bool m_isRouteFollowingActive = false;
 };
@@ -88,9 +87,11 @@ private:
 class StencilWriterGuard
 {
 public:
-  explicit StencilWriterGuard(ref_ptr<PostprocessRenderer> renderer);
+  explicit StencilWriterGuard(ref_ptr<PostprocessRenderer> renderer,
+                              ref_ptr<dp::GraphicsContext> context);
   ~StencilWriterGuard();
 private:
   ref_ptr<PostprocessRenderer> const m_renderer;
+  ref_ptr<dp::GraphicsContext> const m_context;
 };
 }  // namespace df
diff --git a/drape_frontend/render_group.cpp b/drape_frontend/render_group.cpp
index 74b74ce2e7..377385d235 100755
--- a/drape_frontend/render_group.cpp
+++ b/drape_frontend/render_group.cpp
@@ -3,7 +3,7 @@
 
 #include "shaders/program_manager.hpp"
 
-#include "drape/debug_rect_renderer.hpp"
+#include "drape_frontend/debug_rect_renderer.hpp"
 #include "drape/vertex_array_buffer.hpp"
 
 #include "geometry/screenbase.hpp"
@@ -69,14 +69,14 @@ void RenderGroup::SetOverlayVisibility(bool isVisible)
     renderBucket->SetOverlayVisibility(isVisible);
 }
 
-void RenderGroup::Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-                         FrameValues const & frameValues)
+void RenderGroup::Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+                         ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
 {
   auto programPtr = mng->GetProgram(screen.isPerspective() ? m_state.GetProgram3d<gpu::Program>()
                                                            : m_state.GetProgram<gpu::Program>());
   ASSERT(programPtr != nullptr, ());
   programPtr->Bind();
-  dp::ApplyState(m_state, programPtr);
+  dp::ApplyState(m_state, context, programPtr);
 
   for(auto & renderBucket : m_renderBuckets)
     renderBucket->GetBuffer()->Build(programPtr);
@@ -126,7 +126,7 @@ void RenderGroup::Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManager>
   }
 
   for(auto const & renderBucket : m_renderBuckets)
-    renderBucket->RenderDebug(screen);
+    renderBucket->RenderDebug(screen, context, DebugRectRenderer::Instance());
 }
 
 void RenderGroup::AddBucket(drape_ptr<dp::RenderBucket> && bucket)
diff --git a/drape_frontend/render_group.hpp b/drape_frontend/render_group.hpp
index bc196c0ecb..0ec52e3498 100755
--- a/drape_frontend/render_group.hpp
+++ b/drape_frontend/render_group.hpp
@@ -35,7 +35,7 @@ public:
   TileKey const & GetTileKey() const { return m_tileKey; }
 
   virtual void UpdateAnimation();
-  virtual void Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
+  virtual void Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
                       FrameValues const & frameValues) = 0;
 
 protected:
@@ -59,7 +59,7 @@ public:
   bool HasOverlayHandles() const;
   void RemoveOverlay(ref_ptr<dp::OverlayTree> tree);
   void SetOverlayVisibility(bool isVisible);
-  void Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
+  void Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
               FrameValues const & frameValues) override;
 
   void AddBucket(drape_ptr<dp::RenderBucket> && bucket);
diff --git a/drape_frontend/render_node.hpp b/drape_frontend/render_node.hpp
index c2f1de49b0..f4f91e22cd 100644
--- a/drape_frontend/render_node.hpp
+++ b/drape_frontend/render_node.hpp
@@ -4,6 +4,7 @@
 
 #include "shaders/program_manager.hpp"
 
+#include "drape/graphics_context.hpp"
 #include "drape/vertex_array_buffer.hpp"
 #include "drape/pointers.hpp"
 
@@ -18,23 +19,23 @@ public:
   {}
 
   template <typename ParamsType>
-  void Render(ref_ptr<gpu::ProgramManager> mng, ParamsType const & params,
+  void Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ParamsType const & params,
               dp::IndicesRange const & range)
   {
-    Apply(mng, params);
+    Apply(context, mng, params);
     m_buffer->RenderRange(m_state.GetDrawAsLine(), range);
   }
 
   template <typename ParamsType>
-  void Render(ref_ptr<gpu::ProgramManager> mng, ParamsType const & params)
+  void Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ParamsType const & params)
   {
-    Apply(mng, params);
+    Apply(context, mng, params);
     m_buffer->Render(m_state.GetDrawAsLine());
   }
 
 private:
   template <typename ParamsType>
-  void Apply(ref_ptr<gpu::ProgramManager> mng, ParamsType const & params)
+  void Apply(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ParamsType const & params)
   {
     auto prg = mng->GetProgram(m_state.GetProgram<gpu::Program>());
     prg->Bind();
@@ -44,7 +45,7 @@ private:
       m_isBuilt = true;
     }
 
-    dp::ApplyState(m_state, prg);
+    dp::ApplyState(m_state, context, prg);
     mng->GetParamsSetter()->Apply(prg, params);
   }
 
diff --git a/drape_frontend/route_renderer.cpp b/drape_frontend/route_renderer.cpp
index 985a9b5abd..1f05f765a1 100644
--- a/drape_frontend/route_renderer.cpp
+++ b/drape_frontend/route_renderer.cpp
@@ -381,6 +381,7 @@ dp::Color RouteRenderer::GetMaskColor(RouteType routeType, double baseDistance,
 
 void RouteRenderer::RenderSubroute(SubrouteInfo const & subrouteInfo, size_t subrouteDataIndex,
                                    ScreenBase const & screen, bool trafficShown,
+                                   ref_ptr<dp::GraphicsContext> context,
                                    ref_ptr<gpu::ProgramManager> mng,
                                    FrameValues const & frameValues)
 {
@@ -431,7 +432,7 @@ void RouteRenderer::RenderSubroute(SubrouteInfo const & subrouteInfo, size_t sub
   ref_ptr<dp::GpuProgram> prg = mng->GetProgram(style.m_pattern.m_isDashed ?
                                                 gpu::Program::RouteDash : gpu::Program::Route);
   prg->Bind();
-  dp::ApplyState(state, prg);
+  dp::ApplyState(state, context, prg);
   mng->GetParamsSetter()->Apply(prg, params);
 
   // Render buckets.
@@ -441,6 +442,7 @@ void RouteRenderer::RenderSubroute(SubrouteInfo const & subrouteInfo, size_t sub
 
 void RouteRenderer::RenderSubrouteArrows(SubrouteInfo const & subrouteInfo,
                                          ScreenBase const & screen,
+                                         ref_ptr<dp::GraphicsContext> context,
                                          ref_ptr<gpu::ProgramManager> mng,
                                          FrameValues const & frameValues)
 {
@@ -469,13 +471,14 @@ void RouteRenderer::RenderSubrouteArrows(SubrouteInfo const & subrouteInfo,
 
   ref_ptr<dp::GpuProgram> prg = mng->GetProgram(gpu::Program::RouteArrow);
   prg->Bind();
-  dp::ApplyState(state, prg);
+  dp::ApplyState(state, context, prg);
   mng->GetParamsSetter()->Apply(prg, params);
   for (auto const & bucket : subrouteInfo.m_arrowsData->m_renderProperty.m_buckets)
     bucket->Render(state.GetDrawAsLine());
 }
 
 void RouteRenderer::RenderSubrouteMarkers(SubrouteInfo const & subrouteInfo, ScreenBase const & screen,
+                                          ref_ptr<dp::GraphicsContext> context,
                                           ref_ptr<gpu::ProgramManager> mng,
                                           FrameValues const & frameValues)
 {
@@ -509,14 +512,14 @@ void RouteRenderer::RenderSubrouteMarkers(SubrouteInfo const & subrouteInfo, Scr
 
   ref_ptr<dp::GpuProgram> prg = mng->GetProgram(gpu::Program::RouteMarker);
   prg->Bind();
-  dp::ApplyState(state, prg);
+  dp::ApplyState(state, context, prg);
   mng->GetParamsSetter()->Apply(prg, params);
   for (auto const & bucket : subrouteInfo.m_markersData->m_renderProperty.m_buckets)
     bucket->Render(state.GetDrawAsLine());
 }
 
-void RouteRenderer::RenderPreviewData(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-                                      FrameValues const & frameValues)
+void RouteRenderer::RenderPreviewData(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+                                      ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
 {
   if (m_waitForPreviewRenderData || m_previewSegments.empty() || m_previewRenderData.empty())
     return;
@@ -529,7 +532,7 @@ void RouteRenderer::RenderPreviewData(ScreenBase const & screen, ref_ptr<gpu::Pr
   program->Bind();
 
   dp::RenderState const & state = m_previewRenderData.front()->m_state;
-  dp::ApplyState(state, program);
+  dp::ApplyState(state, context, program);
   mng->GetParamsSetter()->Apply(program, params);
 
   ASSERT_EQUAL(m_previewRenderData.size(), m_previewHandlesCache.size(), ());
@@ -541,6 +544,7 @@ void RouteRenderer::RenderPreviewData(ScreenBase const & screen, ref_ptr<gpu::Pr
 }
 
 void RouteRenderer::RenderRoute(ScreenBase const & screen, bool trafficShown,
+                                ref_ptr<dp::GraphicsContext> context,
                                 ref_ptr<gpu::ProgramManager> mng,
                                 FrameValues const & frameValues)
 {
@@ -548,17 +552,17 @@ void RouteRenderer::RenderRoute(ScreenBase const & screen, bool trafficShown,
   {
     // Render subroutes.
     for (size_t i = 0; i < subroute.m_subrouteData.size(); ++i)
-      RenderSubroute(subroute, i, screen, trafficShown, mng, frameValues);
+      RenderSubroute(subroute, i, screen, trafficShown, context, mng, frameValues);
 
     // Render markers.
-    RenderSubrouteMarkers(subroute, screen, mng, frameValues);
+    RenderSubrouteMarkers(subroute, screen, context, mng, frameValues);
 
     // Render arrows.
-    RenderSubrouteArrows(subroute, screen, mng, frameValues);
+    RenderSubrouteArrows(subroute, screen, context, mng, frameValues);
   }
 
   // Render preview.
-  RenderPreviewData(screen, mng, frameValues);
+  RenderPreviewData(screen, context, mng, frameValues);
 }
 
 void RouteRenderer::AddSubrouteData(drape_ptr<SubrouteData> && subrouteData,
diff --git a/drape_frontend/route_renderer.hpp b/drape_frontend/route_renderer.hpp
index 6d29d6db6f..3ace0fe639 100644
--- a/drape_frontend/route_renderer.hpp
+++ b/drape_frontend/route_renderer.hpp
@@ -57,8 +57,8 @@ public:
 
   void UpdateRoute(ScreenBase const & screen, CacheRouteArrowsCallback const & callback);
 
-  void RenderRoute(ScreenBase const & screen, bool trafficShown, ref_ptr<gpu::ProgramManager> mng,
-                   FrameValues const & frameValues);
+  void RenderRoute(ScreenBase const & screen, bool trafficShown, ref_ptr<dp::GraphicsContext> context,
+                   ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
 
   void AddSubrouteData(drape_ptr<SubrouteData> && subrouteData, ref_ptr<gpu::ProgramManager> mng);
   Subroutes const & GetSubroutes() const;
@@ -94,15 +94,16 @@ public:
 
 private:
   void RenderSubroute(SubrouteInfo const & subrouteInfo, size_t subrouteDataIndex,
-                      ScreenBase const & screen, bool trafficShown, ref_ptr<gpu::ProgramManager> mng,
-                      FrameValues const & frameValues);
+                      ScreenBase const & screen, bool trafficShown, ref_ptr<dp::GraphicsContext> context,
+                      ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
   void RenderSubrouteArrows(SubrouteInfo const & subrouteInfo, ScreenBase const & screen,
-                            ref_ptr<gpu::ProgramManager> mng,
+                            ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
                             FrameValues const & frameValues);
   void RenderSubrouteMarkers(SubrouteInfo const & subrouteInfo, ScreenBase const & screen,
-                             ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
-  void RenderPreviewData(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-                         FrameValues const & frameValues);
+                             ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                             FrameValues const & frameValues);
+  void RenderPreviewData(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+                         ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
   void ClearPreviewHandles();
   CirclesPackHandle * GetPreviewHandle(size_t & index);
   dp::Color GetMaskColor(RouteType routeType, double baseDistance, bool arrows) const;
diff --git a/drape_frontend/screen_quad_renderer.cpp b/drape_frontend/screen_quad_renderer.cpp
index dfc8c8ac5c..86e2c7409c 100644
--- a/drape_frontend/screen_quad_renderer.cpp
+++ b/drape_frontend/screen_quad_renderer.cpp
@@ -4,9 +4,6 @@
 #include "shaders/program_manager.hpp"
 
 #include "drape/data_buffer.hpp"
-#include "drape/glconstants.hpp"
-#include "drape/glextensions_list.hpp"
-#include "drape/glfunctions.hpp"
 
 #include <vector>
 
@@ -14,63 +11,34 @@ namespace df
 {
 namespace
 {
-class TextureRendererContext : public RendererContext
+class TextureRenderParams
 {
 public:
-  gpu::Program GetGpuProgram() const override { return gpu::Program::ScreenQuad; }
-
-  void PreRender(ref_ptr<gpu::ProgramManager> mng) override
-  {
-    auto prg = mng->GetProgram(GetGpuProgram());
-
-    BindTexture(m_textureId, prg, "u_colorTex", 0 /* slotIndex */,
-                gl_const::GLLinear, gl_const::GLClampToEdge);
-
-    mng->GetParamsSetter()->Apply(prg, m_params);
-
-    GLFunctions::glDisable(gl_const::GLDepthTest);
-    GLFunctions::glEnable(gl_const::GLBlending);
-  }
-
-  void PostRender() override
+  TextureRenderParams()
+    : m_state(CreateRenderState(gpu::Program::ScreenQuad, DepthLayer::GeometryLayer))
   {
-    GLFunctions::glDisable(gl_const::GLBlending);
-    GLFunctions::glBindTexture(0);
+    m_state.SetDepthTestEnabled(false);
+    m_state.SetBlending(dp::Blending(true));
   }
 
-  void SetParams(uint32_t textureId, float opacity)
+  void SetParams(ref_ptr<gpu::ProgramManager> gpuProgramManager,
+                 ref_ptr<dp::Texture> texture, float opacity)
   {
-    m_textureId = textureId;
+    m_state.SetTexture("u_colorTex", texture);
     m_params.m_opacity = opacity;
   }
 
+  dp::RenderState const & GetRenderState() const { return m_state; }
+  gpu::ScreenQuadProgramParams const & GetProgramParams() const { return m_params; }
+
 private:
-  uint32_t m_textureId = 0;
+  dp::RenderState m_state;
   gpu::ScreenQuadProgramParams m_params;
 };
 }  // namespace
 
-void RendererContext::BindTexture(uint32_t textureId, ref_ptr<dp::GpuProgram> prg,
-                                  std::string const & uniformName, uint8_t slotIndex,
-                                  uint32_t filteringMode, uint32_t wrappingMode)
-{
-  int8_t const textureLocation = prg->GetUniformLocation(uniformName);
-  ASSERT_NOT_EQUAL(textureLocation, -1, ());
-  if (textureLocation < 0)
-    return;
-
-  GLFunctions::glActiveTexture(gl_const::GLTexture0 + slotIndex);
-  GLFunctions::glBindTexture(textureId);
-  GLFunctions::glUniformValuei(textureLocation, slotIndex);
-  GLFunctions::glTexParameter(gl_const::GLMinFilter, filteringMode);
-  GLFunctions::glTexParameter(gl_const::GLMagFilter, filteringMode);
-  GLFunctions::glTexParameter(gl_const::GLWrapS, wrappingMode);
-  GLFunctions::glTexParameter(gl_const::GLWrapT, wrappingMode);
-}
-
 ScreenQuadRenderer::ScreenQuadRenderer()
   : TBase(DrawPrimitive::TriangleStrip)
-  , m_textureRendererContext(make_unique_dp<TextureRendererContext>())
 {
   Rebuild();
 }
@@ -87,21 +55,14 @@ void ScreenQuadRenderer::Rebuild()
   SetAttribute("a_tcoord", bufferIndex, sizeof(float) * 2 /* offset */, 2 /* componentsCount */);
 }
 
-void ScreenQuadRenderer::Render(ref_ptr<gpu::ProgramManager> mng, ref_ptr<RendererContext> context)
+void ScreenQuadRenderer::RenderTexture(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                       ref_ptr<dp::Texture> texture, float opacity)
 {
-  ref_ptr<dp::GpuProgram> prg = mng->GetProgram(context->GetGpuProgram());
-  TBase::Render(prg, [context, mng](){ context->PreRender(mng); }, [context](){ context->PostRender(); });
-}
-
-void ScreenQuadRenderer::RenderTexture(ref_ptr<gpu::ProgramManager> mng, uint32_t textureId,
-                                       float opacity)
-{
-  ASSERT(dynamic_cast<TextureRendererContext *>(m_textureRendererContext.get()) != nullptr, ());
-
-  auto context = static_cast<TextureRendererContext *>(m_textureRendererContext.get());
-  context->SetParams(textureId, opacity);
+  TextureRenderParams params;
+  params.SetParams(mng, texture, opacity);
 
-  Render(mng, make_ref(m_textureRendererContext));
+  auto program = mng->GetProgram(params.GetRenderState().GetProgram<gpu::Program>());
+  TBase::Render(context, program, params.GetRenderState(), mng->GetParamsSetter(), params.GetProgramParams());
 }
 
 void ScreenQuadRenderer::SetTextureRect(m2::RectF const & rect)
diff --git a/drape_frontend/screen_quad_renderer.hpp b/drape_frontend/screen_quad_renderer.hpp
index 6a5fb91fcc..c7ed645b12 100644
--- a/drape_frontend/screen_quad_renderer.hpp
+++ b/drape_frontend/screen_quad_renderer.hpp
@@ -1,18 +1,9 @@
 #pragma once
 
-#include "shaders/programs.hpp"
-
 #include "drape/mesh_object.hpp"
 
 #include "geometry/rect2d.hpp"
 
-#include <string>
-
-namespace dp
-{
-class GpuProgram;
-}  // namespace dp
-
 namespace gpu
 {
 class ProgramManager;
@@ -20,19 +11,6 @@ class ProgramManager;
 
 namespace df
 {
-class RendererContext
-{
-public:
-  virtual ~RendererContext() = default;
-  virtual gpu::Program GetGpuProgram() const = 0;
-  virtual void PreRender(ref_ptr<gpu::ProgramManager> mng) {}
-  virtual void PostRender() {}
-protected:
-  void BindTexture(uint32_t textureId, ref_ptr<dp::GpuProgram> prg,
-                   std::string const & uniformName, uint8_t slotIndex,
-                   uint32_t filteringMode, uint32_t wrappingMode);
-};
-
 class ScreenQuadRenderer: public dp::MeshObject
 {
   using TBase = dp::MeshObject;
@@ -42,14 +20,12 @@ public:
   void SetTextureRect(m2::RectF const & rect);
   m2::RectF const & GetTextureRect() const { return m_textureRect; }
 
-  void Render(ref_ptr<gpu::ProgramManager> mng, ref_ptr<RendererContext> context);
-  void RenderTexture(ref_ptr<gpu::ProgramManager> mng, uint32_t textureId, float opacity);
+  void RenderTexture(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                     ref_ptr<dp::Texture> texture, float opacity);
 
 private:
   void Rebuild();
 
   m2::RectF m_textureRect = m2::RectF(0.0f, 0.0f, 1.0f, 1.0f);
-
-  drape_ptr<RendererContext> m_textureRendererContext;
 };
 }  // namespace df
diff --git a/drape_frontend/selection_shape.cpp b/drape_frontend/selection_shape.cpp
index 7bbb7fb379..740f8341bc 100644
--- a/drape_frontend/selection_shape.cpp
+++ b/drape_frontend/selection_shape.cpp
@@ -140,8 +140,8 @@ bool SelectionShape::IsVisible(ScreenBase const & screen, m2::PointD & pxPos) co
   return false;
 }
 
-void SelectionShape::Render(ScreenBase const & screen, int zoomLevel, ref_ptr<gpu::ProgramManager> mng,
-                            FrameValues const & frameValues)
+void SelectionShape::Render(ScreenBase const & screen, int zoomLevel, ref_ptr<dp::GraphicsContext> context,
+                            ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
 {
   ShowHideAnimation::EState state = m_animation.GetState();
   if (state == ShowHideAnimation::STATE_VISIBLE ||
@@ -165,7 +165,7 @@ void SelectionShape::Render(ScreenBase const & screen, int zoomLevel, ref_ptr<gp
       accuracy /= scale;
     }
     params.m_accuracy = accuracy;
-    m_renderNode->Render(mng, params);
+    m_renderNode->Render(context, mng, params);
   }
 }
 
diff --git a/drape_frontend/selection_shape.hpp b/drape_frontend/selection_shape.hpp
index 469f3aa1d3..3d9e523259 100644
--- a/drape_frontend/selection_shape.hpp
+++ b/drape_frontend/selection_shape.hpp
@@ -5,6 +5,8 @@
 #include "drape_frontend/frame_values.hpp"
 #include "drape_frontend/render_node.hpp"
 
+#include "drape/graphics_context.hpp"
+
 #include "geometry/point2d.hpp"
 #include "geometry/screenbase.hpp"
 
@@ -37,8 +39,8 @@ public:
   void SetPosition(m2::PointD const & position) { m_position = position; }
   void Show(ESelectedObject obj, m2::PointD const & position, double positionZ, bool isAnimate);
   void Hide();
-  void Render(ScreenBase const & screen, int zoomLevel, ref_ptr<gpu::ProgramManager> mng,
-              FrameValues const & frameValues);
+  void Render(ScreenBase const & screen, int zoomLevel, ref_ptr<dp::GraphicsContext> context,
+              ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
 
   bool IsVisible(ScreenBase const & screen, m2::PointD & pxPos) const;
   double GetRadius() const { return m_radius; }
diff --git a/drape_frontend/traffic_renderer.cpp b/drape_frontend/traffic_renderer.cpp
index 3c0f3e0a60..5ec547a761 100644
--- a/drape_frontend/traffic_renderer.cpp
+++ b/drape_frontend/traffic_renderer.cpp
@@ -135,7 +135,8 @@ void TrafficRenderer::OnGeometryReady(int currentZoomLevel)
 }
 
 void TrafficRenderer::RenderTraffic(ScreenBase const & screen, int zoomLevel, float opacity,
-                                    ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
+                                    ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                    FrameValues const & frameValues)
 {
   if (m_renderData.empty() || zoomLevel < kRoadClass0ZoomLevel)
     return;
@@ -150,7 +151,7 @@ void TrafficRenderer::RenderTraffic(ScreenBase const & screen, int zoomLevel, fl
     {
       auto program = mng->GetProgram(renderData.m_state.GetProgram<gpu::Program>());
       program->Bind();
-      dp::ApplyState(renderData.m_state, program);
+      dp::ApplyState(renderData.m_state, context, program);
 
       gpu::TrafficProgramParams params;
       frameValues.SetTo(params);
@@ -167,7 +168,7 @@ void TrafficRenderer::RenderTraffic(ScreenBase const & screen, int zoomLevel, fl
       {
         ref_ptr<dp::GpuProgram> programPtr = mng->GetProgram(program);
         programPtr->Bind();
-        dp::ApplyState(renderData.m_state, programPtr);
+        dp::ApplyState(renderData.m_state, context, programPtr);
 
         gpu::TrafficProgramParams params;
         frameValues.SetTo(params);
@@ -220,7 +221,7 @@ void TrafficRenderer::RenderTraffic(ScreenBase const & screen, int zoomLevel, fl
 
       ref_ptr<dp::GpuProgram> programPtr = mng->GetProgram(program);
       programPtr->Bind();
-      dp::ApplyState(renderData.m_state, programPtr);
+      dp::ApplyState(renderData.m_state, context, programPtr);
 
       gpu::TrafficProgramParams params;
       frameValues.SetTo(params);
diff --git a/drape_frontend/traffic_renderer.hpp b/drape_frontend/traffic_renderer.hpp
index bacc784d2a..4cd4a02121 100644
--- a/drape_frontend/traffic_renderer.hpp
+++ b/drape_frontend/traffic_renderer.hpp
@@ -23,7 +23,7 @@ public:
   void AddRenderData(ref_ptr<gpu::ProgramManager> mng,
                      TrafficRenderData && renderData);
 
-  void RenderTraffic(ScreenBase const & screen, int zoomLevel, float opacity,
+  void RenderTraffic(ScreenBase const & screen, int zoomLevel, float opacity, ref_ptr<dp::GraphicsContext> context,
                      ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
 
   bool HasRenderData() const { return !m_renderData.empty(); }
diff --git a/drape_frontend/transit_scheme_renderer.cpp b/drape_frontend/transit_scheme_renderer.cpp
index 12283f4424..4ff060d7b0 100644
--- a/drape_frontend/transit_scheme_renderer.cpp
+++ b/drape_frontend/transit_scheme_renderer.cpp
@@ -1,5 +1,6 @@
 #include "drape_frontend/transit_scheme_renderer.hpp"
 
+#include "drape_frontend/debug_rect_renderer.hpp"
 #include "drape_frontend/postprocess_renderer.hpp"
 #include "drape_frontend/shape_view_params.hpp"
 #include "drape_frontend/visual_params.hpp"
@@ -128,9 +129,9 @@ void TransitSchemeRenderer::PrepareRenderData(ref_ptr<gpu::ProgramManager> mng,
   currentRenderData.emplace_back(std::move(newRenderData));
 }
 
-void TransitSchemeRenderer::RenderTransit(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
+void TransitSchemeRenderer::RenderTransit(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+                                          ref_ptr<gpu::ProgramManager> mng,
                                           ref_ptr<PostprocessRenderer> postprocessRenderer,
-                                          ref_ptr<dp::GraphicsContext> context,
                                           FrameValues const & frameValues)
 {
   auto const zoomLevel = GetDrawTileScale(screen);
@@ -139,15 +140,15 @@ void TransitSchemeRenderer::RenderTransit(ScreenBase const & screen, ref_ptr<gpu
 
   float const pixelHalfWidth = CalculateHalfWidth(screen);
 
-  RenderLinesCaps(screen, mng, context, frameValues, pixelHalfWidth);
-  RenderLines(screen, mng, frameValues, pixelHalfWidth);
-  RenderMarkers(screen, mng, context, frameValues, pixelHalfWidth);
+  RenderLinesCaps(screen, context, mng, frameValues, pixelHalfWidth);
+  RenderLines(screen, context, mng, frameValues, pixelHalfWidth);
+  RenderMarkers(screen, context, mng, frameValues, pixelHalfWidth);
   {
-    StencilWriterGuard guard(postprocessRenderer);
-    RenderText(screen, mng, frameValues);
+    StencilWriterGuard guard(postprocessRenderer, context);
+    RenderText(screen, context, mng, frameValues);
   }
   // Render only for debug purpose.
-  //RenderStubs(screen, mng, frameValues);
+  //RenderStubs(screen, context, mng, frameValues);
 }
 
 void TransitSchemeRenderer::CollectOverlays(ref_ptr<dp::OverlayTree> tree, ScreenBase const & modelView)
@@ -174,16 +175,16 @@ void TransitSchemeRenderer::RemoveOverlays(ref_ptr<dp::OverlayTree> tree, std::v
     data.m_bucket->RemoveOverlayHandles(tree);
 }
 
-void TransitSchemeRenderer::RenderLinesCaps(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-                                            ref_ptr<dp::GraphicsContext> context,
-                                            FrameValues const & frameValues, float pixelHalfWidth)
+void TransitSchemeRenderer::RenderLinesCaps(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+                                            ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues,
+                                            float pixelHalfWidth)
 {
   context->Clear(dp::ClearBits::DepthBit);
   for (auto & renderData : m_linesCapsRenderData)
   {
     ref_ptr<dp::GpuProgram> program = mng->GetProgram(renderData.m_state.GetProgram<gpu::Program>());
     program->Bind();
-    dp::ApplyState(renderData.m_state, program);
+    dp::ApplyState(renderData.m_state, context, program);
 
     gpu::TransitProgramParams params;
     frameValues.SetTo(params);
@@ -197,14 +198,15 @@ void TransitSchemeRenderer::RenderLinesCaps(ScreenBase const & screen, ref_ptr<g
   }
 }
 
-void TransitSchemeRenderer::RenderLines(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-                                        FrameValues const & frameValues, float pixelHalfWidth)
+void TransitSchemeRenderer::RenderLines(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+                                        ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues,
+                                        float pixelHalfWidth)
 {
   for (auto & renderData : m_linesRenderData)
   {
     ref_ptr<dp::GpuProgram> program = mng->GetProgram(renderData.m_state.GetProgram<gpu::Program>());
     program->Bind();
-    dp::ApplyState(renderData.m_state, program);
+    dp::ApplyState(renderData.m_state, context, program);
 
     gpu::TransitProgramParams params;
     frameValues.SetTo(params);
@@ -217,16 +219,16 @@ void TransitSchemeRenderer::RenderLines(ScreenBase const & screen, ref_ptr<gpu::
   }
 }
 
-void TransitSchemeRenderer::RenderMarkers(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-                                          ref_ptr<dp::GraphicsContext> context,
-                                          FrameValues const & frameValues, float pixelHalfWidth)
+void TransitSchemeRenderer::RenderMarkers(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+                                          ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues,
+                                          float pixelHalfWidth)
 {
   context->Clear(dp::ClearBits::DepthBit);
   for (auto & renderData : m_markersRenderData)
   {
     auto program = mng->GetProgram(renderData.m_state.GetProgram<gpu::Program>());
     program->Bind();
-    dp::ApplyState(renderData.m_state, program);
+    dp::ApplyState(renderData.m_state, context, program);
 
     gpu::TransitProgramParams params;
     frameValues.SetTo(params);
@@ -241,15 +243,15 @@ void TransitSchemeRenderer::RenderMarkers(ScreenBase const & screen, ref_ptr<gpu
   }
 }
 
-void TransitSchemeRenderer::RenderText(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-                                       FrameValues const & frameValues)
+void TransitSchemeRenderer::RenderText(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+                                       ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
 {
   auto const & glyphParams = df::VisualParams::Instance().GetGlyphVisualParams();
   for (auto & renderData : m_textRenderData)
   {
     ref_ptr<dp::GpuProgram> program = mng->GetProgram(renderData.m_state.GetProgram<gpu::Program>());
     program->Bind();
-    dp::ApplyState(renderData.m_state, program);
+    dp::ApplyState(renderData.m_state, context, program);
 
     gpu::MapProgramParams params;
     frameValues.SetTo(params);
@@ -267,18 +269,18 @@ void TransitSchemeRenderer::RenderText(ScreenBase const & screen, ref_ptr<gpu::P
 
     renderData.m_bucket->Render(false /* draw as line */);
 
-    renderData.m_bucket->RenderDebug(screen);
+    renderData.m_bucket->RenderDebug(screen, context, DebugRectRenderer::Instance());
   }
 }
 
-void TransitSchemeRenderer::RenderStubs(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-                                        FrameValues const & frameValues)
+void TransitSchemeRenderer::RenderStubs(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
+                                        ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
 {
   for (auto & renderData : m_colorSymbolRenderData)
   {
     auto program = mng->GetProgram(renderData.m_state.GetProgram<gpu::Program>());
     program->Bind();
-    dp::ApplyState(renderData.m_state, program);
+    dp::ApplyState(renderData.m_state, context, program);
 
     gpu::MapProgramParams params;
     frameValues.SetTo(params);
@@ -288,7 +290,7 @@ void TransitSchemeRenderer::RenderStubs(ScreenBase const & screen, ref_ptr<gpu::
 
     renderData.m_bucket->Render(false /* draw as line */);
 
-    renderData.m_bucket->RenderDebug(screen);
+    renderData.m_bucket->RenderDebug(screen, context, DebugRectRenderer::Instance());
   }
 }
 }  // namespace df
diff --git a/drape_frontend/transit_scheme_renderer.hpp b/drape_frontend/transit_scheme_renderer.hpp
index 9369023a2f..1f0e5ca122 100644
--- a/drape_frontend/transit_scheme_renderer.hpp
+++ b/drape_frontend/transit_scheme_renderer.hpp
@@ -28,9 +28,8 @@ public:
 
   bool IsSchemeVisible(int zoomLevel) const;
 
-  void RenderTransit(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
+  void RenderTransit(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
                      ref_ptr<PostprocessRenderer> postprocessRenderer,
-                     ref_ptr<dp::GraphicsContext> context,
                      FrameValues const & frameValues);
 
   void CollectOverlays(ref_ptr<dp::OverlayTree> tree, ScreenBase const & modelView);
@@ -55,15 +54,15 @@ private:
   void CollectOverlays(ref_ptr<dp::OverlayTree> tree, ScreenBase const & modelView,
                        std::vector<TransitRenderData> & renderData);
 
-  void RenderLines(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
+  void RenderLines(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
                    FrameValues const & frameValues, float pixelHalfWidth);
-  void RenderLinesCaps(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-                       ref_ptr<dp::GraphicsContext> context, FrameValues const & frameValues, float pixelHalfWidth);
-  void RenderMarkers(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
-                     ref_ptr<dp::GraphicsContext> context, FrameValues const & frameValues, float pixelHalfWidth);
-  void RenderText(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
+  void RenderLinesCaps(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                       FrameValues const & frameValues, float pixelHalfWidth);
+  void RenderMarkers(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                     FrameValues const & frameValues, float pixelHalfWidth);
+  void RenderText(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
                   FrameValues const & frameValues);
-  void RenderStubs(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng,
+  void RenderStubs(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
                    FrameValues const & frameValues);
 
   bool HasRenderData() const;