Review fixes.

39 files changed, 205 insertions, 234 deletions

diff --git a/drape_frontend/arrow3d.cpp b/drape_frontend/arrow3d.cpp
index 4e08172ef3..1447b7cef5 100644
--- a/drape_frontend/arrow3d.cpp
+++ b/drape_frontend/arrow3d.cpp
@@ -30,7 +30,7 @@ df::ColorConstant const kArrow3DColor = "Arrow3D";
 df::ColorConstant const kArrow3DOutlineColor = "Arrow3DOutline";
 
 Arrow3d::Arrow3d()
-  : TBase(DrawPrimitive::Triangles)
+  : Base(DrawPrimitive::Triangles)
   , m_state(CreateRenderState(gpu::Program::Arrow3d, DepthLayer::OverlayLayer))
 {
   m_state.SetDepthTestEnabled(false);
@@ -51,9 +51,7 @@ 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,
   };
 
-  std::vector<float> normals;
-  GenerateNormalsForTriangles(vertices, kComponentsInVertex, normals);
-  normals.reserve(vertices.size());
+  std::vector<float> normals = GenerateNormalsForTriangles(vertices, kComponentsInVertex);
 
   auto const verticesBufferInd = 0;
   SetBuffer(verticesBufferInd, std::move(vertices), sizeof(float) * kComponentsInVertex);
@@ -84,13 +82,13 @@ void Arrow3d::SetPositionObsolete(bool obsolete)
   m_obsoletePosition = obsolete;
 }
 
-void Arrow3d::Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
-                     bool routingMode)
+void Arrow3d::Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                     ScreenBase const & screen, bool routingMode)
 {
   // Render shadow.
   if (screen.isPerspective())
   {
-    RenderArrow(screen, context, mng, gpu::Program::Arrow3dShadow,
+    RenderArrow(context, mng, screen, gpu::Program::Arrow3dShadow,
                 df::GetColorConstant(df::kArrow3DShadowColor), 0.05f /* dz */,
                 routingMode ? kOutlineScale : 1.0f /* scaleFactor */, false /* hasNormals */);
   }
@@ -102,18 +100,18 @@ void Arrow3d::Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> con
   if (routingMode)
   {
     dp::Color const outlineColor = df::GetColorConstant(df::kArrow3DOutlineColor);
-    RenderArrow(screen, context, mng, gpu::Program::Arrow3dOutline,
+    RenderArrow(context, mng, screen, gpu::Program::Arrow3dOutline,
                 dp::Color(outlineColor.GetRed(), outlineColor.GetGreen(), outlineColor.GetBlue(), color.GetAlpha()),
                 0.0f /* dz */, kOutlineScale /* scaleFactor */, false /* hasNormals */);
   }
 
   // Render arrow.
-  RenderArrow(screen, context, mng, gpu::Program::Arrow3d, color, 0.0f /* dz */, 1.0f /* scaleFactor */,
+  RenderArrow(context, mng, screen, gpu::Program::Arrow3d, color, 0.0f /* dz */, 1.0f /* scaleFactor */,
               true /* hasNormals */);
 }
 
-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,
+void Arrow3d::RenderArrow(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                          ScreenBase const & screen, gpu::Program program, dp::Color const & color, float dz,
                           float scaleFactor, bool hasNormals)
 {
   gpu::Arrow3dProgramParams params;
@@ -122,7 +120,7 @@ void Arrow3d::RenderArrow(ScreenBase const & screen, ref_ptr<dp::GraphicsContext
   params.m_color = glsl::ToVec4(color);
 
   auto gpuProgram = mng->GetProgram(program);
-  TBase::Render(context, gpuProgram, m_state, mng->GetParamsSetter(), params);
+  Base::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 4d170b4046..3250092061 100644
--- a/drape_frontend/arrow3d.hpp
+++ b/drape_frontend/arrow3d.hpp
@@ -26,7 +26,7 @@ namespace df
 {
 class Arrow3d: public dp::MeshObject
 {
-  using TBase = dp::MeshObject;
+  using Base = dp::MeshObject;
 public:
   Arrow3d();
 
@@ -35,13 +35,13 @@ public:
   void SetTexture(ref_ptr<dp::TextureManager> texMng);
   void SetPositionObsolete(bool obsolete);
 
-  void Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+  void Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
               bool routingMode);
 
 private:
   math::Matrix<float, 4, 4> CalculateTransform(ScreenBase const & screen, float dz,
                                                float scaleFactor) const;
-  void RenderArrow(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+  void RenderArrow(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
                    gpu::Program program, dp::Color const & color, float dz, float scaleFactor,
                    bool hasNormals);
 
diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp
index 1e34b502f4..77ce842ef8 100644
--- a/drape_frontend/backend_renderer.cpp
+++ b/drape_frontend/backend_renderer.cpp
@@ -92,8 +92,8 @@ unique_ptr<threads::IRoutine> BackendRenderer::CreateRoutine()
 
 void BackendRenderer::RecacheGui(gui::TWidgetsInitInfo const & initInfo, bool needResetOldGui)
 {
-  auto context = m_contextFactory->GetResourcesUploadContext();
-  drape_ptr<gui::LayerRenderer> layerRenderer = m_guiCacher.RecacheWidgets(initInfo, m_texMng, make_ref(context));
+  auto context = make_ref(m_contextFactory->GetResourcesUploadContext());
+  drape_ptr<gui::LayerRenderer> layerRenderer = m_guiCacher.RecacheWidgets(context, initInfo, m_texMng);
   drape_ptr<Message> outputMsg = make_unique_dp<GuiLayerRecachedMessage>(std::move(layerRenderer), needResetOldGui);
   m_commutator->PostMessage(ThreadsCommutator::RenderThread, std::move(outputMsg), MessagePriority::Normal);
 }
@@ -101,8 +101,8 @@ void BackendRenderer::RecacheGui(gui::TWidgetsInitInfo const & initInfo, bool ne
 #ifdef RENDER_DEBUG_INFO_LABELS
 void BackendRenderer::RecacheDebugLabels()
 {
-  auto context = m_contextFactory->GetResourcesUploadContext();
-  drape_ptr<gui::LayerRenderer> layerRenderer = m_guiCacher.RecacheDebugLabels(m_texMng, make_ref(context));
+  auto context = make_ref(m_contextFactory->GetResourcesUploadContext());
+  drape_ptr<gui::LayerRenderer> layerRenderer = m_guiCacher.RecacheDebugLabels(context, m_texMng);
   drape_ptr<Message> outputMsg = make_unique_dp<GuiLayerRecachedMessage>(std::move(layerRenderer), false);
   m_commutator->PostMessage(ThreadsCommutator::RenderThread, std::move(outputMsg), MessagePriority::Normal);
 }
@@ -110,8 +110,8 @@ void BackendRenderer::RecacheDebugLabels()
 
 void BackendRenderer::RecacheChoosePositionMark()
 {
-  auto context = m_contextFactory->GetResourcesUploadContext();
-  drape_ptr<gui::LayerRenderer> layerRenderer = m_guiCacher.RecacheChoosePositionMark(m_texMng, make_ref(context));
+  auto context = make_ref(m_contextFactory->GetResourcesUploadContext());
+  drape_ptr<gui::LayerRenderer> layerRenderer = m_guiCacher.RecacheChoosePositionMark(context, m_texMng);
   drape_ptr<Message> outputMsg = make_unique_dp<GuiLayerRecachedMessage>(std::move(layerRenderer), false);
   m_commutator->PostMessage(ThreadsCommutator::RenderThread, std::move(outputMsg), MessagePriority::Normal);
 }
@@ -313,8 +313,8 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
   case Message::AddSubroute:
     {
       ref_ptr<AddSubrouteMessage> msg = message;
-      auto context = m_contextFactory->GetResourcesUploadContext();
-      m_routeBuilder->Build(msg->GetSubrouteId(), msg->GetSubroute(), m_texMng, make_ref(context),
+      auto context = make_ref(m_contextFactory->GetResourcesUploadContext());
+      m_routeBuilder->Build(context, msg->GetSubrouteId(), msg->GetSubroute(), m_texMng,
                             msg->GetRecacheId());
       break;
     }
@@ -322,8 +322,8 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
   case Message::CacheSubrouteArrows:
     {
       ref_ptr<CacheSubrouteArrowsMessage> msg = message;
-      auto context = m_contextFactory->GetResourcesUploadContext();
-      m_routeBuilder->BuildArrows(msg->GetSubrouteId(), msg->GetBorders(), m_texMng, make_ref(context),
+      auto context = make_ref(m_contextFactory->GetResourcesUploadContext());
+      m_routeBuilder->BuildArrows(context, msg->GetSubrouteId(), msg->GetBorders(), m_texMng,
                                   msg->GetRecacheId());
       break;
     }
@@ -359,8 +359,8 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
       ref_ptr<CacheCirclesPackMessage> msg = message;
       drape_ptr<CirclesPackRenderData> data = make_unique_dp<CirclesPackRenderData>();
       data->m_pointsCount = msg->GetPointsCount();
-      auto context = m_contextFactory->GetResourcesUploadContext();
-      CirclesPackShape::Draw(m_texMng, make_ref(context), *data.get());
+      auto context = make_ref(m_contextFactory->GetResourcesUploadContext());
+      CirclesPackShape::Draw(context, m_texMng, *data.get());
       m_commutator->PostMessage(ThreadsCommutator::RenderThread,
                                 make_unique_dp<FlushCirclesPackMessage>(
                                   std::move(data), msg->GetDestination()),
@@ -410,8 +410,8 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
       auto const & tileKey = msg->GetKey();
       if (m_requestedTiles->CheckTileKey(tileKey) && m_readManager->CheckTileKey(tileKey))
       {
-        auto context = m_contextFactory->GetResourcesUploadContext();
-        m_trafficGenerator->FlushSegmentsGeometry(tileKey, msg->GetSegments(), m_texMng, make_ref(context));
+        auto context = make_ref(m_contextFactory->GetResourcesUploadContext());
+        m_trafficGenerator->FlushSegmentsGeometry(context, tileKey, msg->GetSegments(), m_texMng);
       }
       break;
     }
diff --git a/drape_frontend/circles_pack_shape.cpp b/drape_frontend/circles_pack_shape.cpp
index 553b109715..05be2f0f3f 100644
--- a/drape_frontend/circles_pack_shape.cpp
+++ b/drape_frontend/circles_pack_shape.cpp
@@ -136,7 +136,7 @@ size_t CirclesPackHandle::GetPointsCount() const
   return m_buffer.size() / dp::Batcher::VertexPerQuad;
 }
 
-void CirclesPackShape::Draw(ref_ptr<dp::TextureManager> texMng, ref_ptr<dp::GraphicsContext> context,
+void CirclesPackShape::Draw(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::TextureManager> texMng,
                             CirclesPackRenderData & data)
 {
   ASSERT_NOT_EQUAL(data.m_pointsCount, 0, ());
diff --git a/drape_frontend/circles_pack_shape.hpp b/drape_frontend/circles_pack_shape.hpp
index 065b7374e0..baf033da8f 100644
--- a/drape_frontend/circles_pack_shape.hpp
+++ b/drape_frontend/circles_pack_shape.hpp
@@ -69,7 +69,7 @@ private:
 class CirclesPackShape
 {
 public:
-  static void Draw(ref_ptr<dp::TextureManager> texMng, ref_ptr<dp::GraphicsContext> context,
+  static void Draw(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::TextureManager> texMng,
                    CirclesPackRenderData & data);
 };
 }  // namespace df
diff --git a/drape_frontend/debug_rect_renderer.cpp b/drape_frontend/debug_rect_renderer.cpp
index f550d4a1e3..83e56c7497 100644
--- a/drape_frontend/debug_rect_renderer.cpp
+++ b/drape_frontend/debug_rect_renderer.cpp
@@ -24,13 +24,13 @@ ref_ptr<DebugRectRenderer> DebugRectRenderer::Instance()
 }
 
 DebugRectRenderer::DebugRectRenderer()
-  : TBase(DrawPrimitive::LineStrip)
+  : Base(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 */);
+  Base::SetBuffer(0 /* bufferInd */, {} /* vertices */, static_cast<uint32_t>(sizeof(float) * 2));
+  Base::SetAttribute("a_position", 0 /* bufferInd */, 0.0f /* offset */, 2 /* componentsCount */);
 }
 
 DebugRectRenderer::~DebugRectRenderer()
@@ -48,7 +48,7 @@ void DebugRectRenderer::Destroy()
 {
   m_program = nullptr;
   m_paramsSetter = nullptr;
-  TBase::Reset();
+  Base::Reset();
 }
 
 bool DebugRectRenderer::IsEnabled() const
@@ -73,7 +73,9 @@ void DebugRectRenderer::SetArrow(m2::PointF const & arrowStart, m2::PointF const
   PixelPointToScreenSpace(screen, arrowEnd, vertices);
   PixelPointToScreenSpace(screen, arrowEnd - dir * 20 - side * 10, vertices);
 
-  TBase::UpdateBuffer(0 /* bufferInd */, std::move(vertices));
+  if (!Base::IsInitialized())
+    Base::Build(m_program);
+  Base::UpdateBuffer(0 /* bufferInd */, std::move(vertices));
 }
 
 void DebugRectRenderer::SetRect(m2::RectF const & rect, ScreenBase const & screen)
@@ -85,7 +87,9 @@ void DebugRectRenderer::SetRect(m2::RectF const & rect, ScreenBase const & scree
   PixelPointToScreenSpace(screen, rect.RightBottom(), vertices);
   PixelPointToScreenSpace(screen, rect.LeftBottom(), vertices);
 
-  TBase::UpdateBuffer(0 /* bufferInd */, std::move(vertices));
+  if (!Base::IsInitialized())
+    Base::Build(m_program);
+  Base::UpdateBuffer(0 /* bufferInd */, std::move(vertices));
 }
 
 void DebugRectRenderer::DrawRect(ref_ptr<dp::GraphicsContext> context, ScreenBase const & screen,
@@ -99,7 +103,7 @@ void DebugRectRenderer::DrawRect(ref_ptr<dp::GraphicsContext> context, ScreenBas
   gpu::DebugRectProgramParams params;
   params.m_color = glsl::ToVec4(color);
 
-  TBase::Render(context, m_program, m_state, m_paramsSetter, params);
+  Base::Render(context, m_program, m_state, m_paramsSetter, params);
 };
 
 void DebugRectRenderer::DrawArrow(ref_ptr<dp::GraphicsContext> context, ScreenBase const & screen,
@@ -108,7 +112,7 @@ void DebugRectRenderer::DrawArrow(ref_ptr<dp::GraphicsContext> context, ScreenBa
   if (!m_isEnabled)
     return;
 
-  if (data.m_arrowStart.EqualDxDy(data.m_arrowEnd, 1e-5))
+  if (data.m_arrowStart.EqualDxDy(data.m_arrowEnd, 1e-5f))
     return;
 
   SetArrow(data.m_arrowStart, data.m_arrowEnd, screen);
@@ -116,6 +120,6 @@ void DebugRectRenderer::DrawArrow(ref_ptr<dp::GraphicsContext> context, ScreenBa
   gpu::DebugRectProgramParams params;
   params.m_color = glsl::ToVec4(data.m_arrowColor);
 
-  TBase::Render(context, m_program, m_state, m_paramsSetter, params);
+  Base::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
index a1b0486df4..bd62fe016e 100644
--- a/drape_frontend/debug_rect_renderer.hpp
+++ b/drape_frontend/debug_rect_renderer.hpp
@@ -10,15 +10,11 @@
 #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
+class DebugRectRenderer: public dp::MeshObject, public dp::DebugRenderer
 {
-  using TBase = dp::MeshObject;
+  using Base = dp::MeshObject;
 public:
   static ref_ptr<DebugRectRenderer> Instance();
 
diff --git a/drape_frontend/drape_api_renderer.cpp b/drape_frontend/drape_api_renderer.cpp
index cb7074cef9..9688ebf823 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<dp::GraphicsContext> context,
-                              ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
+void DrapeApiRenderer::Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                              ScreenBase const & screen, FrameValues const & frameValues)
 {
   if (m_properties.empty())
     return;
@@ -55,7 +55,7 @@ void DrapeApiRenderer::Render(ScreenBase const & screen, ref_ptr<dp::GraphicsCon
     {
       auto program = mng->GetProgram(bucket.first.GetProgram<gpu::Program>());
       program->Bind();
-      dp::ApplyState(bucket.first, context, program);
+      dp::ApplyState(context, program, bucket.first);
 
       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 f0fa3b9ddb..18bcffe76c 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<dp::GraphicsContext> context,
-              ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
+  void Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
+              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 1982b7eb8f..899bff567c 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -1,6 +1,7 @@
 #include "drape_frontend/frontend_renderer.hpp"
 #include "drape_frontend/animation/interpolation_holder.hpp"
 #include "drape_frontend/animation_system.hpp"
+#include "drape_frontend/debug_rect_renderer.hpp"
 #include "drape_frontend/drape_measurer.hpp"
 #include "drape_frontend/drape_notifier.hpp"
 #include "drape_frontend/gui/drape_gui.hpp"
@@ -15,7 +16,6 @@
 
 #include "shaders/programs.hpp"
 
-#include "drape_frontend/debug_rect_renderer.hpp"
 #include "drape/framebuffer.hpp"
 #include "drape/support_manager.hpp"
 #include "drape/utils/glyph_usage_tracker.hpp"
@@ -1240,13 +1240,11 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView, bool activeFram
       {
         ASSERT(m_myPositionController->IsModeHasPosition(), ());
         m_selectionShape->SetPosition(m_myPositionController->Position());
-        m_selectionShape->Render(modelView, m_currentZoomLevel, context, make_ref(m_gpuProgramManager),
-                                 m_frameValues);
+        m_selectionShape->Render(context, make_ref(m_gpuProgramManager), modelView, m_currentZoomLevel, m_frameValues);
       }
       else if (selectedObject == SelectionShape::OBJECT_POI)
       {
-        m_selectionShape->Render(modelView, m_currentZoomLevel, context, make_ref(m_gpuProgramManager),
-                                 m_frameValues);
+        m_selectionShape->Render(context, make_ref(m_gpuProgramManager), modelView, m_currentZoomLevel, m_frameValues);
       }
     }
 
@@ -1256,13 +1254,13 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView, bool activeFram
       RenderUserMarksLayer(modelView, DepthLayer::LocalAdsMarkLayer);
     }
 
-    m_gpsTrackRenderer->RenderTrack(modelView, m_currentZoomLevel, context, make_ref(m_gpuProgramManager),
+    m_gpsTrackRenderer->RenderTrack(context, make_ref(m_gpuProgramManager), modelView, m_currentZoomLevel,
                                     m_frameValues);
 
     if (m_selectionShape != nullptr &&
         m_selectionShape->GetSelectedObject() == SelectionShape::OBJECT_USER_MARK)
     {
-      m_selectionShape->Render(modelView, m_currentZoomLevel, context, make_ref(m_gpuProgramManager),
+      m_selectionShape->Render(context, make_ref(m_gpuProgramManager), modelView, m_currentZoomLevel,
                                m_frameValues);
     }
 
@@ -1280,7 +1278,7 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView, bool activeFram
     if (!HasRouteData())
       RenderTransitSchemeLayer(modelView);
 
-    m_drapeApiRenderer->Render(modelView, context, make_ref(m_gpuProgramManager), m_frameValues);
+    m_drapeApiRenderer->Render(context, make_ref(m_gpuProgramManager), modelView, m_frameValues);
 
     for (auto const & arrow : m_overlayTree->GetDisplacementInfo())
       DebugRectRenderer::Instance()->DrawArrow(context, modelView, arrow);
@@ -1289,7 +1287,7 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView, bool activeFram
   if (!m_postprocessRenderer->EndFrame(context, make_ref(m_gpuProgramManager)))
     return;
 
-  m_myPositionController->Render(modelView, m_currentZoomLevel, context, make_ref(m_gpuProgramManager),
+  m_myPositionController->Render(context, make_ref(m_gpuProgramManager), modelView, m_currentZoomLevel,
                                  m_frameValues);
 
   if (m_guiRenderer != nullptr)
@@ -1386,7 +1384,7 @@ void FrontendRenderer::RenderTransitSchemeLayer(ScreenBase const & modelView)
   if (m_transitSchemeEnabled && m_transitSchemeRenderer->IsSchemeVisible(m_currentZoomLevel))
   {
     RenderTransitBackground();
-    m_transitSchemeRenderer->RenderTransit(modelView, context, make_ref(m_gpuProgramManager),
+    m_transitSchemeRenderer->RenderTransit(context, make_ref(m_gpuProgramManager), modelView,
                                            make_ref(m_postprocessRenderer), m_frameValues);
   }
 }
@@ -1397,8 +1395,8 @@ void FrontendRenderer::RenderTrafficLayer(ScreenBase const & modelView)
   context->Clear(dp::ClearBits::DepthBit);
   if (m_trafficRenderer->HasRenderData())
   {
-    m_trafficRenderer->RenderTraffic(modelView, m_currentZoomLevel, 1.0f /* opacity */,
-                                     context, make_ref(m_gpuProgramManager), m_frameValues);
+    m_trafficRenderer->RenderTraffic(context, make_ref(m_gpuProgramManager), modelView,
+                                     m_currentZoomLevel, 1.0f /* opacity */, m_frameValues);
   }
 }
 
@@ -1424,8 +1422,8 @@ void FrontendRenderer::RenderRouteLayer(ScreenBase const & modelView)
 
   auto context = make_ref(m_contextFactory->GetDrawContext());
   context->Clear(dp::ClearBits::DepthBit);
-  m_routeRenderer->RenderRoute(modelView, m_trafficRenderer->HasRenderData(),
-                               context, make_ref(m_gpuProgramManager), m_frameValues);
+  m_routeRenderer->RenderRoute(context, make_ref(m_gpuProgramManager), modelView, m_trafficRenderer->HasRenderData(),
+                               m_frameValues);
 }
 
 void FrontendRenderer::RenderUserMarksLayer(ScreenBase const & modelView, DepthLayer layerId)
@@ -1505,7 +1503,7 @@ void FrontendRenderer::RenderSingleGroup(ref_ptr<dp::GraphicsContext> context, S
                                          ref_ptr<BaseRenderGroup> group)
 {
   group->UpdateAnimation();
-  group->Render(modelView, context, make_ref(m_gpuProgramManager), m_frameValues);
+  group->Render(context, make_ref(m_gpuProgramManager), modelView, m_frameValues);
 }
 
 void FrontendRenderer::RefreshProjection(ScreenBase const & screen)
diff --git a/drape_frontend/gps_track_renderer.cpp b/drape_frontend/gps_track_renderer.cpp
index d5e8dec3b1..9d78c195fd 100644
--- a/drape_frontend/gps_track_renderer.cpp
+++ b/drape_frontend/gps_track_renderer.cpp
@@ -189,10 +189,8 @@ dp::Color GpsTrackRenderer::GetColorBySpeed(double speed) const
   return df::GetColorConstant(df::kTrackHumanSpeedColor);
 }
 
-void GpsTrackRenderer::RenderTrack(ScreenBase const & screen, int zoomLevel,
-                                   ref_ptr<dp::GraphicsContext> context,
-                                   ref_ptr<gpu::ProgramManager> mng,
-                                   FrameValues const & frameValues)
+void GpsTrackRenderer::RenderTrack(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                   ScreenBase const & screen, int zoomLevel, FrameValues const & frameValues)
 {
   if (zoomLevel < kMinVisibleZoomLevel)
     return;
@@ -310,7 +308,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, context, program);
+  dp::ApplyState(context, program, state);
   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 64489f5b23..c0b93208d7 100644
--- a/drape_frontend/gps_track_renderer.hpp
+++ b/drape_frontend/gps_track_renderer.hpp
@@ -30,10 +30,8 @@ public:
   void UpdatePoints(std::vector<GpsTrackPoint> const & toAdd,
                     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);
+  void RenderTrack(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
+                   int zoomLevel, FrameValues const & frameValues);
 
   void Update();
   void Clear();
diff --git a/drape_frontend/gui/layer_render.cpp b/drape_frontend/gui/layer_render.cpp
index 9186a28a30..75c24fe7d3 100644
--- a/drape_frontend/gui/layer_render.cpp
+++ b/drape_frontend/gui/layer_render.cpp
@@ -54,7 +54,7 @@ void LayerRenderer::Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::Pr
     if (routingActive && (r.first == gui::WIDGET_COMPASS || r.first == gui::WIDGET_RULER))
       continue;
 
-    r.second->Render(screen, context, mng);
+    r.second->Render(context, mng, screen);
   }
 }
 
@@ -197,9 +197,9 @@ private:
 };
 }  // namespace
 
-drape_ptr<LayerRenderer> LayerCacher::RecacheWidgets(TWidgetsInitInfo const & initInfo,
-                                                     ref_ptr<dp::TextureManager> textures,
-                                                     ref_ptr<dp::GraphicsContext> context)
+drape_ptr<LayerRenderer> LayerCacher::RecacheWidgets(ref_ptr<dp::GraphicsContext> context,
+                                                     TWidgetsInitInfo const & initInfo,
+                                                     ref_ptr<dp::TextureManager> textures)
 {
   using TCacheShape = std::function<m2::PointF(Position anchor, ref_ptr<LayerRenderer> renderer,
                                                ref_ptr<dp::TextureManager> textures)>;
@@ -224,8 +224,8 @@ drape_ptr<LayerRenderer> LayerCacher::RecacheWidgets(TWidgetsInitInfo const & in
   return renderer;
 }
 
-drape_ptr<LayerRenderer> LayerCacher::RecacheChoosePositionMark(ref_ptr<dp::TextureManager> textures,
-                                                                ref_ptr<dp::GraphicsContext> context)
+drape_ptr<LayerRenderer> LayerCacher::RecacheChoosePositionMark(ref_ptr<dp::GraphicsContext> context,
+                                                                ref_ptr<dp::TextureManager> textures)
 {
   m2::PointF const surfSize = DrapeGui::Instance().GetSurfaceSize();
   drape_ptr<LayerRenderer> renderer = make_unique_dp<LayerRenderer>();
@@ -240,8 +240,8 @@ drape_ptr<LayerRenderer> LayerCacher::RecacheChoosePositionMark(ref_ptr<dp::Text
 }
 
 #ifdef RENDER_DEBUG_INFO_LABELS
-drape_ptr<LayerRenderer> LayerCacher::RecacheDebugLabels(ref_ptr<dp::TextureManager> textures,
-                                                         ref_ptr<dp::GraphicsContext> context)
+drape_ptr<LayerRenderer> LayerCacher::RecacheDebugLabels(ref_ptr<dp::GraphicsContext> context,
+                                                         ref_ptr<dp::TextureManager> textures)
 {
   drape_ptr<LayerRenderer> renderer = make_unique_dp<LayerRenderer>();
 
diff --git a/drape_frontend/gui/layer_render.hpp b/drape_frontend/gui/layer_render.hpp
index 7de93972ac..408d151d14 100644
--- a/drape_frontend/gui/layer_render.hpp
+++ b/drape_frontend/gui/layer_render.hpp
@@ -57,15 +57,15 @@ private:
 class LayerCacher
 {
 public:
-  drape_ptr<LayerRenderer> RecacheWidgets(TWidgetsInitInfo const & initInfo,
-                                          ref_ptr<dp::TextureManager> textures,
-                                          ref_ptr<dp::GraphicsContext> context);
-  drape_ptr<LayerRenderer> RecacheChoosePositionMark(ref_ptr<dp::TextureManager> textures,
-                                                     ref_ptr<dp::GraphicsContext> context);
+  drape_ptr<LayerRenderer> RecacheWidgets(ref_ptr<dp::GraphicsContext> context,
+                                          TWidgetsInitInfo const & initInfo,
+                                          ref_ptr<dp::TextureManager> textures);
+  drape_ptr<LayerRenderer> RecacheChoosePositionMark(ref_ptr<dp::GraphicsContext> context,
+                                                     ref_ptr<dp::TextureManager> textures);
 
 #ifdef RENDER_DEBUG_INFO_LABELS
-  drape_ptr<LayerRenderer> RecacheDebugLabels(ref_ptr<dp::TextureManager> textures,
-                                              ref_ptr<dp::GraphicsContext> context);
+  drape_ptr<LayerRenderer> RecacheDebugLabels(ref_ptr<dp::GraphicsContext> context,
+                                              ref_ptr<dp::TextureManager> textures);
 #endif
 
 private:
diff --git a/drape_frontend/gui/shape.cpp b/drape_frontend/gui/shape.cpp
index d1cf7f5c85..a2e3b06fb2 100644
--- a/drape_frontend/gui/shape.cpp
+++ b/drape_frontend/gui/shape.cpp
@@ -87,8 +87,8 @@ void ShapeRenderer::Build(ref_ptr<gpu::ProgramManager> mng)
   });
 }
 
-void ShapeRenderer::Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
-                           ref_ptr<gpu::ProgramManager> mng)
+void ShapeRenderer::Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                           ScreenBase const & screen)
 {
   std::array<float, 16> m = {};
   m2::RectD const & pxRect = screen.PixelRectIn3d();
@@ -106,7 +106,7 @@ void ShapeRenderer::Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContex
 
     ref_ptr<dp::GpuProgram> prg = mng->GetProgram(info.m_state.GetProgram<gpu::Program>());
     prg->Bind();
-    dp::ApplyState(info.m_state, context, prg);
+    dp::ApplyState(context, prg, info.m_state);
 
     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 22845e998d..2dd51d8b0c 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<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng);
+  void Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen);
   void AddShape(dp::RenderState const & state, drape_ptr<dp::RenderBucket> && bucket);
   void AddShapeControl(ShapeControl && control);
 
diff --git a/drape_frontend/my_position.cpp b/drape_frontend/my_position.cpp
index 13705af15d..0a2dffe46f 100644
--- a/drape_frontend/my_position.cpp
+++ b/drape_frontend/my_position.cpp
@@ -97,10 +97,8 @@ void MyPosition::SetPositionObsolete(bool obsolete)
   m_arrow3d.SetPositionObsolete(obsolete);
 }
 
-void MyPosition::RenderAccuracy(ScreenBase const & screen, int zoomLevel,
-                                ref_ptr<dp::GraphicsContext> context,
-                                ref_ptr<gpu::ProgramManager> mng,
-                                FrameValues const & frameValues)
+void MyPosition::RenderAccuracy(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                ScreenBase const & screen, int zoomLevel, FrameValues const & frameValues)
 {
   m2::PointD accuracyPoint(m_position.x + m_accuracy, m_position.y);
   auto const pixelAccuracy =
@@ -119,16 +117,14 @@ void MyPosition::RenderAccuracy(ScreenBase const & screen, int zoomLevel,
   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)
+void MyPosition::RenderMyPosition(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                  ScreenBase const & screen, int zoomLevel, FrameValues const & frameValues)
 {
   if (m_showAzimuth)
   {
     m_arrow3d.SetPosition(m2::PointD(m_position));
     m_arrow3d.SetAzimuth(m_azimuth);
-    m_arrow3d.Render(screen, context, mng, m_isRoutingMode);
+    m_arrow3d.Render(context, mng, screen, m_isRoutingMode);
   }
   else
   {
@@ -247,8 +243,7 @@ void MyPosition::CachePointPosition(ref_ptr<dp::TextureManager> mng)
 }
 
 void MyPosition::RenderPart(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
-                            gpu::ShapesProgramParams const & params,
-                            EMyPositionPart part)
+                            gpu::ShapesProgramParams const & params, EMyPositionPart part)
 {
   TPart const & p = m_parts[part];
   m_nodes[p.second].Render(context, mng, params, p.first);
diff --git a/drape_frontend/my_position.hpp b/drape_frontend/my_position.hpp
index 09264eb5a6..f1ed728d6e 100644
--- a/drape_frontend/my_position.hpp
+++ b/drape_frontend/my_position.hpp
@@ -31,15 +31,11 @@ public:
   void SetRoutingMode(bool routingMode);
   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);
+  void RenderAccuracy(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                      ScreenBase const & screen, int zoomLevel, FrameValues const & frameValues);
+
+  void RenderMyPosition(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                        ScreenBase const & screen, int zoomLevel, FrameValues const & frameValues);
 
 private:
   void CacheAccuracySector(ref_ptr<dp::TextureManager> mng);
diff --git a/drape_frontend/my_position_controller.cpp b/drape_frontend/my_position_controller.cpp
index cc40be1192..589b39a546 100644
--- a/drape_frontend/my_position_controller.cpp
+++ b/drape_frontend/my_position_controller.cpp
@@ -609,10 +609,8 @@ bool MyPositionController::UpdateViewportWithAutoZoom()
   return false;
 }
 
-void MyPositionController::Render(ScreenBase const & screen, int zoomLevel,
-                                  ref_ptr<dp::GraphicsContext> context,
-                                  ref_ptr<gpu::ProgramManager> mng,
-                                  FrameValues const & frameValues)
+void MyPositionController::Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                  ScreenBase const & screen, int zoomLevel, FrameValues const & frameValues)
 {
   CheckIsWaitingForLocation();
   CheckNotFollowRouting();
@@ -640,8 +638,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, context, mng, frameValues);
-    m_shape->RenderMyPosition(screen, zoomLevel, context, mng, frameValues);
+    m_shape->RenderAccuracy(context, mng, screen, zoomLevel, frameValues);
+    m_shape->RenderMyPosition(context, mng, screen, zoomLevel, frameValues);
   }
 }
 
diff --git a/drape_frontend/my_position_controller.hpp b/drape_frontend/my_position_controller.hpp
index 75369ff490..f7e211bbab 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<dp::GraphicsContext> context,
-              ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
+  void Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+              ScreenBase const & screen, int zoomLevel, 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 76c465a623..bcbfe8c268 100644
--- a/drape_frontend/postprocess_renderer.cpp
+++ b/drape_frontend/postprocess_renderer.cpp
@@ -25,6 +25,7 @@ public:
     m_state.SetDepthTestEnabled(false);
     m_state.SetBlending(dp::Blending(false));
   }
+  virtual ~SMAABaseRenderParams() = default;
 
   dp::RenderState const & GetRenderState() const { return m_state; }
   gpu::SMAAProgramParams const & GetProgramParams() const { return m_params; }
@@ -69,11 +70,11 @@ public:
   }
 };
 
-class SMAAFinalRendeParams : public SMAABaseRenderParams
+class SMAAFinalRenderParams : public SMAABaseRenderParams
 {
   using TBase = SMAABaseRenderParams;
 public:
-  SMAAFinalRendeParams(): TBase(gpu::Program::SmaaFinal) {}
+  SMAAFinalRenderParams(): TBase(gpu::Program::SmaaFinal) {}
 
   void SetParams(ref_ptr<dp::Texture> colorTexture, ref_ptr<dp::Texture> blendingWeightTexture,
                  uint32_t width, uint32_t height)
@@ -304,7 +305,7 @@ bool PostprocessRenderer::EndFrame(ref_ptr<dp::GraphicsContext> context, ref_ptr
 
       context->Clear(dp::ClearBits::ColorBit);
 
-      SMAAFinalRendeParams params;
+      SMAAFinalRenderParams params;
       params.SetParams(m_mainFramebuffer->GetTexture(),
                        m_blendingWeightFramebuffer->GetTexture(),
                        m_width, m_height);
diff --git a/drape_frontend/postprocess_renderer.hpp b/drape_frontend/postprocess_renderer.hpp
index 4bf46f20f5..adb2ce447e 100644
--- a/drape_frontend/postprocess_renderer.hpp
+++ b/drape_frontend/postprocess_renderer.hpp
@@ -1,18 +1,17 @@
 #pragma once
 
+#include "shaders/program_params.hpp"
+
 #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
 
@@ -87,8 +86,7 @@ private:
 class StencilWriterGuard
 {
 public:
-  explicit StencilWriterGuard(ref_ptr<PostprocessRenderer> renderer,
-                              ref_ptr<dp::GraphicsContext> context);
+  StencilWriterGuard(ref_ptr<PostprocessRenderer> renderer, ref_ptr<dp::GraphicsContext> context);
   ~StencilWriterGuard();
 private:
   ref_ptr<PostprocessRenderer> const m_renderer;
diff --git a/drape_frontend/render_group.cpp b/drape_frontend/render_group.cpp
index 377385d235..ec7b5cde14 100755
--- a/drape_frontend/render_group.cpp
+++ b/drape_frontend/render_group.cpp
@@ -69,14 +69,14 @@ void RenderGroup::SetOverlayVisibility(bool isVisible)
     renderBucket->SetOverlayVisibility(isVisible);
 }
 
-void RenderGroup::Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
-                         ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
+void RenderGroup::Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                         ScreenBase const & screen, 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, context, programPtr);
+  dp::ApplyState(context, programPtr, m_state);
 
   for(auto & renderBucket : m_renderBuckets)
     renderBucket->GetBuffer()->Build(programPtr);
@@ -126,7 +126,7 @@ void RenderGroup::Render(ScreenBase const & screen, ref_ptr<dp::GraphicsContext>
   }
 
   for(auto const & renderBucket : m_renderBuckets)
-    renderBucket->RenderDebug(screen, context, DebugRectRenderer::Instance());
+    renderBucket->RenderDebug(context, screen, 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 0ec52e3498..9c71d04a1d 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<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+  virtual void Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
                       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<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+  void Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
               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 f4f91e22cd..4416e6a1cb 100644
--- a/drape_frontend/render_node.hpp
+++ b/drape_frontend/render_node.hpp
@@ -45,7 +45,7 @@ private:
       m_isBuilt = true;
     }
 
-    dp::ApplyState(m_state, context, prg);
+    dp::ApplyState(context, prg, m_state);
     mng->GetParamsSetter()->Apply(prg, params);
   }
 
diff --git a/drape_frontend/route_builder.cpp b/drape_frontend/route_builder.cpp
index a1b3ca9424..65cab233c6 100644
--- a/drape_frontend/route_builder.cpp
+++ b/drape_frontend/route_builder.cpp
@@ -14,8 +14,8 @@ RouteBuilder::RouteBuilder(FlushFn && flushFn, FlushArrowsFn && flushArrowsFn,
   , m_flushMarkersFn(std::move(flushMarkersFn))
 {}
 
-void RouteBuilder::Build(dp::DrapeID subrouteId, SubrouteConstPtr subroute,
-                         ref_ptr<dp::TextureManager> textures, ref_ptr<dp::GraphicsContext> context, int recacheId)
+void RouteBuilder::Build(ref_ptr<dp::GraphicsContext> context, dp::DrapeID subrouteId, SubrouteConstPtr subroute,
+                         ref_ptr<dp::TextureManager> textures, int recacheId)
 {
   RouteCacheData cacheData;
   cacheData.m_polyline = subroute->m_polyline;
@@ -52,8 +52,8 @@ void RouteBuilder::ClearRouteCache()
   m_routeCache.clear();
 }
 
-void RouteBuilder::BuildArrows(dp::DrapeID subrouteId, std::vector<ArrowBorders> const & borders,
-                               ref_ptr<dp::TextureManager> textures, ref_ptr<dp::GraphicsContext> context,
+void RouteBuilder::BuildArrows(ref_ptr<dp::GraphicsContext> context, dp::DrapeID subrouteId,
+                               std::vector<ArrowBorders> const & borders, ref_ptr<dp::TextureManager> textures,
                                int recacheId)
 {
   auto it = m_routeCache.find(subrouteId);
diff --git a/drape_frontend/route_builder.hpp b/drape_frontend/route_builder.hpp
index d3019c2386..8f230a6f04 100644
--- a/drape_frontend/route_builder.hpp
+++ b/drape_frontend/route_builder.hpp
@@ -31,11 +31,11 @@ public:
   RouteBuilder(FlushFn && flushFn, FlushArrowsFn && flushArrowsFn,
                FlushMarkersFn && flushMarkersFn);
 
-  void Build(dp::DrapeID subrouteId, SubrouteConstPtr subroute,
-             ref_ptr<dp::TextureManager> textures, ref_ptr<dp::GraphicsContext> context, int recacheId);
+  void Build(ref_ptr<dp::GraphicsContext> context, dp::DrapeID subrouteId, SubrouteConstPtr subroute,
+             ref_ptr<dp::TextureManager> textures, int recacheId);
 
-  void BuildArrows(dp::DrapeID subrouteId, std::vector<ArrowBorders> const & borders,
-                   ref_ptr<dp::TextureManager> textures, ref_ptr<dp::GraphicsContext> context, int recacheId);
+  void BuildArrows(ref_ptr<dp::GraphicsContext> context, dp::DrapeID subrouteId,
+                   std::vector<ArrowBorders> const & borders, ref_ptr<dp::TextureManager> textures, int recacheId);
 
   void ClearRouteCache();
 
diff --git a/drape_frontend/route_renderer.cpp b/drape_frontend/route_renderer.cpp
index 1f05f765a1..9b0225ba73 100644
--- a/drape_frontend/route_renderer.cpp
+++ b/drape_frontend/route_renderer.cpp
@@ -379,11 +379,9 @@ dp::Color RouteRenderer::GetMaskColor(RouteType routeType, double baseDistance,
   return {0, 0, 0, 0};
 }
 
-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)
+void RouteRenderer::RenderSubroute(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                   SubrouteInfo const & subrouteInfo, size_t subrouteDataIndex,
+                                   ScreenBase const & screen, bool trafficShown, FrameValues const & frameValues)
 {
   ASSERT_LESS(subrouteDataIndex, subrouteInfo.m_subrouteData.size(), ());
   if (subrouteInfo.m_subrouteData[subrouteDataIndex]->m_renderProperty.m_buckets.empty())
@@ -432,7 +430,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, context, prg);
+  dp::ApplyState(context, prg, state);
   mng->GetParamsSetter()->Apply(prg, params);
 
   // Render buckets.
@@ -440,10 +438,8 @@ void RouteRenderer::RenderSubroute(SubrouteInfo const & subrouteInfo, size_t sub
     bucket->Render(state.GetDrawAsLine());
 }
 
-void RouteRenderer::RenderSubrouteArrows(SubrouteInfo const & subrouteInfo,
-                                         ScreenBase const & screen,
-                                         ref_ptr<dp::GraphicsContext> context,
-                                         ref_ptr<gpu::ProgramManager> mng,
+void RouteRenderer::RenderSubrouteArrows(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                         SubrouteInfo const & subrouteInfo, ScreenBase const & screen,
                                          FrameValues const & frameValues)
 {
   if (subrouteInfo.m_arrowsData == nullptr ||
@@ -471,15 +467,14 @@ void RouteRenderer::RenderSubrouteArrows(SubrouteInfo const & subrouteInfo,
 
   ref_ptr<dp::GpuProgram> prg = mng->GetProgram(gpu::Program::RouteArrow);
   prg->Bind();
-  dp::ApplyState(state, context, prg);
+  dp::ApplyState(context, prg, state);
   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,
+void RouteRenderer::RenderSubrouteMarkers(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                          SubrouteInfo const & subrouteInfo, ScreenBase const & screen,
                                           FrameValues const & frameValues)
 {
   if (subrouteInfo.m_markersData == nullptr ||
@@ -512,14 +507,14 @@ void RouteRenderer::RenderSubrouteMarkers(SubrouteInfo const & subrouteInfo, Scr
 
   ref_ptr<dp::GpuProgram> prg = mng->GetProgram(gpu::Program::RouteMarker);
   prg->Bind();
-  dp::ApplyState(state, context, prg);
+  dp::ApplyState(context, prg, state);
   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<dp::GraphicsContext> context,
-                                      ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
+void RouteRenderer::RenderPreviewData(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                      ScreenBase const & screen, FrameValues const & frameValues)
 {
   if (m_waitForPreviewRenderData || m_previewSegments.empty() || m_previewRenderData.empty())
     return;
@@ -532,7 +527,7 @@ void RouteRenderer::RenderPreviewData(ScreenBase const & screen, ref_ptr<dp::Gra
   program->Bind();
 
   dp::RenderState const & state = m_previewRenderData.front()->m_state;
-  dp::ApplyState(state, context, program);
+  dp::ApplyState(context, program, state);
   mng->GetParamsSetter()->Apply(program, params);
 
   ASSERT_EQUAL(m_previewRenderData.size(), m_previewHandlesCache.size(), ());
@@ -543,26 +538,24 @@ void RouteRenderer::RenderPreviewData(ScreenBase const & screen, ref_ptr<dp::Gra
   }
 }
 
-void RouteRenderer::RenderRoute(ScreenBase const & screen, bool trafficShown,
-                                ref_ptr<dp::GraphicsContext> context,
-                                ref_ptr<gpu::ProgramManager> mng,
-                                FrameValues const & frameValues)
+void RouteRenderer::RenderRoute(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                ScreenBase const & screen, bool trafficShown, FrameValues const & frameValues)
 {
   for (auto const & subroute : m_subroutes)
   {
     // Render subroutes.
     for (size_t i = 0; i < subroute.m_subrouteData.size(); ++i)
-      RenderSubroute(subroute, i, screen, trafficShown, context, mng, frameValues);
+      RenderSubroute(context, mng, subroute, i, screen, trafficShown, frameValues);
 
     // Render markers.
-    RenderSubrouteMarkers(subroute, screen, context, mng, frameValues);
+    RenderSubrouteMarkers(context, mng, subroute, screen, frameValues);
 
     // Render arrows.
-    RenderSubrouteArrows(subroute, screen, context, mng, frameValues);
+    RenderSubrouteArrows(context, mng, subroute, screen, frameValues);
   }
 
   // Render preview.
-  RenderPreviewData(screen, context, mng, frameValues);
+  RenderPreviewData(context, mng, screen, frameValues);
 }
 
 void RouteRenderer::AddSubrouteData(drape_ptr<SubrouteData> && subrouteData,
diff --git a/drape_frontend/route_renderer.hpp b/drape_frontend/route_renderer.hpp
index 3ace0fe639..fb8e41c065 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<dp::GraphicsContext> context,
-                   ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
+  void RenderRoute(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
+                   bool trafficShown, FrameValues const & frameValues);
 
   void AddSubrouteData(drape_ptr<SubrouteData> && subrouteData, ref_ptr<gpu::ProgramManager> mng);
   Subroutes const & GetSubroutes() const;
@@ -93,17 +93,17 @@ public:
   bool HasData() const;
 
 private:
-  void 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);
-  void RenderSubrouteArrows(SubrouteInfo const & subrouteInfo, ScreenBase const & screen,
-                            ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+  void RenderSubroute(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                      SubrouteInfo const & subrouteInfo, size_t subrouteDataIndex,
+                      ScreenBase const & screen, bool trafficShown, FrameValues const & frameValues);
+  void RenderSubrouteArrows(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                            SubrouteInfo const & subrouteInfo, ScreenBase const & screen,
                             FrameValues const & frameValues);
-  void RenderSubrouteMarkers(SubrouteInfo const & subrouteInfo, ScreenBase const & screen,
-                             ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+  void RenderSubrouteMarkers(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                             SubrouteInfo const & subrouteInfo, ScreenBase const & screen,
                              FrameValues const & frameValues);
-  void RenderPreviewData(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
-                         ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
+  void RenderPreviewData(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                         ScreenBase const & screen, 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 86e2c7409c..0ef2dd4ded 100644
--- a/drape_frontend/screen_quad_renderer.cpp
+++ b/drape_frontend/screen_quad_renderer.cpp
@@ -38,7 +38,7 @@ private:
 }  // namespace
 
 ScreenQuadRenderer::ScreenQuadRenderer()
-  : TBase(DrawPrimitive::TriangleStrip)
+  : Base(DrawPrimitive::TriangleStrip)
 {
   Rebuild();
 }
@@ -62,7 +62,7 @@ void ScreenQuadRenderer::RenderTexture(ref_ptr<dp::GraphicsContext> context, ref
   params.SetParams(mng, texture, opacity);
 
   auto program = mng->GetProgram(params.GetRenderState().GetProgram<gpu::Program>());
-  TBase::Render(context, program, params.GetRenderState(), mng->GetParamsSetter(), params.GetProgramParams());
+  Base::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 c7ed645b12..06c2b60583 100644
--- a/drape_frontend/screen_quad_renderer.hpp
+++ b/drape_frontend/screen_quad_renderer.hpp
@@ -13,7 +13,7 @@ namespace df
 {
 class ScreenQuadRenderer: public dp::MeshObject
 {
-  using TBase = dp::MeshObject;
+  using Base = dp::MeshObject;
 public:
   ScreenQuadRenderer();
 
diff --git a/drape_frontend/selection_shape.cpp b/drape_frontend/selection_shape.cpp
index 740f8341bc..7e15cedd54 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<dp::GraphicsContext> context,
-                            ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
+void SelectionShape::Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                            ScreenBase const & screen, int zoomLevel, FrameValues const & frameValues)
 {
   ShowHideAnimation::EState state = m_animation.GetState();
   if (state == ShowHideAnimation::STATE_VISIBLE ||
diff --git a/drape_frontend/selection_shape.hpp b/drape_frontend/selection_shape.hpp
index 3d9e523259..4d721ee851 100644
--- a/drape_frontend/selection_shape.hpp
+++ b/drape_frontend/selection_shape.hpp
@@ -39,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<dp::GraphicsContext> context,
-              ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
+  void Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
+              int zoomLevel, FrameValues const & frameValues);
 
   bool IsVisible(ScreenBase const & screen, m2::PointD & pxPos) const;
   double GetRadius() const { return m_radius; }
diff --git a/drape_frontend/traffic_generator.cpp b/drape_frontend/traffic_generator.cpp
index 02f9918c74..08a4256f6d 100644
--- a/drape_frontend/traffic_generator.cpp
+++ b/drape_frontend/traffic_generator.cpp
@@ -227,8 +227,8 @@ void TrafficGenerator::GenerateSegmentsGeometry(MwmSet::MwmId const & mwmId, Til
   }
 }
 
-void TrafficGenerator::FlushSegmentsGeometry(TileKey const & tileKey, TrafficSegmentsGeometry const & geom,
-                                             ref_ptr<dp::TextureManager> textures, ref_ptr<dp::GraphicsContext> context)
+void TrafficGenerator::FlushSegmentsGeometry(ref_ptr<dp::GraphicsContext> context, TileKey const & tileKey,
+                                             TrafficSegmentsGeometry const & geom, ref_ptr<dp::TextureManager> textures)
 {
   FillColorsCache(textures);
 
diff --git a/drape_frontend/traffic_generator.hpp b/drape_frontend/traffic_generator.hpp
index 01c2336070..a5d4e12c7e 100644
--- a/drape_frontend/traffic_generator.hpp
+++ b/drape_frontend/traffic_generator.hpp
@@ -170,8 +170,8 @@ public:
   void Init();
   void ClearGLDependentResources();
 
-  void FlushSegmentsGeometry(TileKey const & tileKey, TrafficSegmentsGeometry const & geom,
-                             ref_ptr<dp::TextureManager> textures, ref_ptr<dp::GraphicsContext> context);
+  void FlushSegmentsGeometry(ref_ptr<dp::GraphicsContext> context, TileKey const & tileKey,
+                             TrafficSegmentsGeometry const & geom, ref_ptr<dp::TextureManager> textures);
   void UpdateColoring(TrafficSegmentsColoring const & coloring);
 
   void ClearCache();
diff --git a/drape_frontend/traffic_renderer.cpp b/drape_frontend/traffic_renderer.cpp
index 5ec547a761..b220aa32c6 100644
--- a/drape_frontend/traffic_renderer.cpp
+++ b/drape_frontend/traffic_renderer.cpp
@@ -134,8 +134,8 @@ void TrafficRenderer::OnGeometryReady(int currentZoomLevel)
   }), m_renderData.end());
 }
 
-void TrafficRenderer::RenderTraffic(ScreenBase const & screen, int zoomLevel, float opacity,
-                                    ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+void TrafficRenderer::RenderTraffic(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                    ScreenBase const & screen, int zoomLevel, float opacity,
                                     FrameValues const & frameValues)
 {
   if (m_renderData.empty() || zoomLevel < kRoadClass0ZoomLevel)
@@ -151,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, context, program);
+      dp::ApplyState(context, program, renderData.m_state);
 
       gpu::TrafficProgramParams params;
       frameValues.SetTo(params);
@@ -168,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, context, programPtr);
+        dp::ApplyState(context, programPtr, renderData.m_state);
 
         gpu::TrafficProgramParams params;
         frameValues.SetTo(params);
@@ -221,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, context, programPtr);
+      dp::ApplyState(context, programPtr, renderData.m_state);
 
       gpu::TrafficProgramParams params;
       frameValues.SetTo(params);
diff --git a/drape_frontend/traffic_renderer.hpp b/drape_frontend/traffic_renderer.hpp
index 4cd4a02121..a5c9299b1c 100644
--- a/drape_frontend/traffic_renderer.hpp
+++ b/drape_frontend/traffic_renderer.hpp
@@ -23,8 +23,8 @@ public:
   void AddRenderData(ref_ptr<gpu::ProgramManager> mng,
                      TrafficRenderData && renderData);
 
-  void RenderTraffic(ScreenBase const & screen, int zoomLevel, float opacity, ref_ptr<dp::GraphicsContext> context,
-                     ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues);
+  void RenderTraffic(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                     ScreenBase const & screen, int zoomLevel, float opacity, 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 4ff060d7b0..dd8582cda2 100644
--- a/drape_frontend/transit_scheme_renderer.cpp
+++ b/drape_frontend/transit_scheme_renderer.cpp
@@ -129,9 +129,8 @@ void TransitSchemeRenderer::PrepareRenderData(ref_ptr<gpu::ProgramManager> mng,
   currentRenderData.emplace_back(std::move(newRenderData));
 }
 
-void TransitSchemeRenderer::RenderTransit(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
-                                          ref_ptr<gpu::ProgramManager> mng,
-                                          ref_ptr<PostprocessRenderer> postprocessRenderer,
+void TransitSchemeRenderer::RenderTransit(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                          ScreenBase const & screen, ref_ptr<PostprocessRenderer> postprocessRenderer,
                                           FrameValues const & frameValues)
 {
   auto const zoomLevel = GetDrawTileScale(screen);
@@ -140,15 +139,15 @@ void TransitSchemeRenderer::RenderTransit(ScreenBase const & screen, ref_ptr<dp:
 
   float const pixelHalfWidth = CalculateHalfWidth(screen);
 
-  RenderLinesCaps(screen, context, mng, frameValues, pixelHalfWidth);
-  RenderLines(screen, context, mng, frameValues, pixelHalfWidth);
-  RenderMarkers(screen, context, mng, frameValues, pixelHalfWidth);
+  RenderLinesCaps(context, mng, screen, frameValues, pixelHalfWidth);
+  RenderLines(context, mng, screen, frameValues, pixelHalfWidth);
+  RenderMarkers(context, mng, screen, frameValues, pixelHalfWidth);
   {
     StencilWriterGuard guard(postprocessRenderer, context);
-    RenderText(screen, context, mng, frameValues);
+    RenderText(context, mng, screen, frameValues);
   }
   // Render only for debug purpose.
-  //RenderStubs(screen, context, mng, frameValues);
+  //RenderStubs(context, mng, screen, frameValues);
 }
 
 void TransitSchemeRenderer::CollectOverlays(ref_ptr<dp::OverlayTree> tree, ScreenBase const & modelView)
@@ -175,8 +174,8 @@ void TransitSchemeRenderer::RemoveOverlays(ref_ptr<dp::OverlayTree> tree, std::v
     data.m_bucket->RemoveOverlayHandles(tree);
 }
 
-void TransitSchemeRenderer::RenderLinesCaps(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
-                                            ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues,
+void TransitSchemeRenderer::RenderLinesCaps(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                            ScreenBase const & screen, FrameValues const & frameValues,
                                             float pixelHalfWidth)
 {
   context->Clear(dp::ClearBits::DepthBit);
@@ -184,7 +183,7 @@ void TransitSchemeRenderer::RenderLinesCaps(ScreenBase const & screen, ref_ptr<d
   {
     ref_ptr<dp::GpuProgram> program = mng->GetProgram(renderData.m_state.GetProgram<gpu::Program>());
     program->Bind();
-    dp::ApplyState(renderData.m_state, context, program);
+    dp::ApplyState(context, program, renderData.m_state);
 
     gpu::TransitProgramParams params;
     frameValues.SetTo(params);
@@ -198,15 +197,15 @@ void TransitSchemeRenderer::RenderLinesCaps(ScreenBase const & screen, ref_ptr<d
   }
 }
 
-void TransitSchemeRenderer::RenderLines(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
-                                        ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues,
+void TransitSchemeRenderer::RenderLines(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                        ScreenBase const & screen, 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, context, program);
+    dp::ApplyState(context, program, renderData.m_state);
 
     gpu::TransitProgramParams params;
     frameValues.SetTo(params);
@@ -219,8 +218,8 @@ void TransitSchemeRenderer::RenderLines(ScreenBase const & screen, ref_ptr<dp::G
   }
 }
 
-void TransitSchemeRenderer::RenderMarkers(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
-                                          ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues,
+void TransitSchemeRenderer::RenderMarkers(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                          ScreenBase const & screen, FrameValues const & frameValues,
                                           float pixelHalfWidth)
 {
   context->Clear(dp::ClearBits::DepthBit);
@@ -228,7 +227,7 @@ void TransitSchemeRenderer::RenderMarkers(ScreenBase const & screen, ref_ptr<dp:
   {
     auto program = mng->GetProgram(renderData.m_state.GetProgram<gpu::Program>());
     program->Bind();
-    dp::ApplyState(renderData.m_state, context, program);
+    dp::ApplyState(context, program, renderData.m_state);
 
     gpu::TransitProgramParams params;
     frameValues.SetTo(params);
@@ -243,15 +242,15 @@ void TransitSchemeRenderer::RenderMarkers(ScreenBase const & screen, ref_ptr<dp:
   }
 }
 
-void TransitSchemeRenderer::RenderText(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
-                                       ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
+void TransitSchemeRenderer::RenderText(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                       ScreenBase const & screen, 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, context, program);
+    dp::ApplyState(context, program, renderData.m_state);
 
     gpu::MapProgramParams params;
     frameValues.SetTo(params);
@@ -269,18 +268,18 @@ void TransitSchemeRenderer::RenderText(ScreenBase const & screen, ref_ptr<dp::Gr
 
     renderData.m_bucket->Render(false /* draw as line */);
 
-    renderData.m_bucket->RenderDebug(screen, context, DebugRectRenderer::Instance());
+    renderData.m_bucket->RenderDebug(context, screen, DebugRectRenderer::Instance());
   }
 }
 
-void TransitSchemeRenderer::RenderStubs(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context,
-                                        ref_ptr<gpu::ProgramManager> mng, FrameValues const & frameValues)
+void TransitSchemeRenderer::RenderStubs(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                                        ScreenBase const & screen, 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, context, program);
+    dp::ApplyState(context, program, renderData.m_state);
 
     gpu::MapProgramParams params;
     frameValues.SetTo(params);
@@ -290,7 +289,7 @@ void TransitSchemeRenderer::RenderStubs(ScreenBase const & screen, ref_ptr<dp::G
 
     renderData.m_bucket->Render(false /* draw as line */);
 
-    renderData.m_bucket->RenderDebug(screen, context, DebugRectRenderer::Instance());
+    renderData.m_bucket->RenderDebug(context, screen, DebugRectRenderer::Instance());
   }
 }
 }  // namespace df
diff --git a/drape_frontend/transit_scheme_renderer.hpp b/drape_frontend/transit_scheme_renderer.hpp
index 1f0e5ca122..56926201b2 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<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
-                     ref_ptr<PostprocessRenderer> postprocessRenderer,
-                     FrameValues const & frameValues);
+  void RenderTransit(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
+                     ref_ptr<PostprocessRenderer> postprocessRenderer, FrameValues const & frameValues);
 
   void CollectOverlays(ref_ptr<dp::OverlayTree> tree, ScreenBase const & modelView);
 
@@ -54,15 +53,15 @@ private:
   void CollectOverlays(ref_ptr<dp::OverlayTree> tree, ScreenBase const & modelView,
                        std::vector<TransitRenderData> & renderData);
 
-  void RenderLines(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+  void RenderLines(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
                    FrameValues const & frameValues, float pixelHalfWidth);
-  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,
+  void RenderLinesCaps(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+                       ScreenBase const & screen, FrameValues const & frameValues, float pixelHalfWidth);
+  void RenderMarkers(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
                      FrameValues const & frameValues, float pixelHalfWidth);
-  void RenderText(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+  void RenderText(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
                   FrameValues const & frameValues);
-  void RenderStubs(ScreenBase const & screen, ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
+  void RenderStubs(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng, ScreenBase const & screen,
                    FrameValues const & frameValues);
 
   bool HasRenderData() const;