Review fixes.

author: Daria Volvenkova <d.volvenkova@corp.mail.ru> 2018-08-16 18:48:20 +0300
committer: Roman Kuznetsov <r.kuznetsow@gmail.com> 2018-08-17 13:11:53 +0300
commit: 04c0ffbab4df4bee1e229474787b98feb4d6ae06 (patch)
tree: 702742ea61542b85e400e7aa34540d7894dd93de
parent: 5ab189afac15e9e97aef702e69e0d883bc8532b9 (diff)
59 files changed, 318 insertions, 313 deletions
diff --git a/drape/debug_renderer.hpp b/drape/debug_renderer.hpp
index 39e82d3317..48dffed937 100644
--- a/drape/debug_renderer.hpp
+++ b/drape/debug_renderer.hpp
@@ -7,9 +7,10 @@ namespace dp
 {
 class GraphicsContext;
 
-class IDebugRenderer
+class DebugRenderer
 {
 public:
+  virtual ~DebugRenderer() = default;
   virtual bool IsEnabled() const = 0;
   virtual void DrawRect(ref_ptr<GraphicsContext> context, ScreenBase const & screen,
                         m2::RectF const & rect, Color const & color) = 0;
diff --git a/drape/dynamic_texture.hpp b/drape/dynamic_texture.hpp
index a795c50d90..877c40c168 100644
--- a/drape/dynamic_texture.hpp
+++ b/drape/dynamic_texture.hpp
@@ -10,6 +10,7 @@ namespace dp
 template<typename TIndexer, typename TResourceKey, Texture::ResourceType TResourceType>
 class DynamicTexture : public Texture
 {
+  using Base = Texture;
 public:
   ~DynamicTexture() override
   {
@@ -25,6 +26,18 @@ public:
     return m_indexer->MapResource(static_cast<TResourceKey const &>(key), newResource);
   }
 
+  void Create(Params const & params) override
+  {
+    ASSERT(Base::IsPowerOfTwo(params.m_width, params.m_height), (params.m_width, params.m_height));
+    Base::Create(params);
+  }
+
+  void Create(Params const & params, ref_ptr<void> data) override
+  {
+    ASSERT(Base::IsPowerOfTwo(params.m_width, params.m_height), (params.m_width, params.m_height));
+    Base::Create(params, data);
+  }
+
   void UpdateState() override
   {
     // Create texture before first uploading.
diff --git a/drape/graphics_context.hpp b/drape/graphics_context.hpp
index c78184cd8a..be750a2c4a 100644
--- a/drape/graphics_context.hpp
+++ b/drape/graphics_context.hpp
@@ -35,10 +35,10 @@ enum class StencilAction : uint8_t
   Keep,
   Zero,
   Replace,
-  Incr,
-  IncrWrap,
-  Decr,
-  DecrWrap,
+  Increment,
+  IncrementWrap,
+  Decrement,
+  DecrementWrap,
   Invert
 };
 
diff --git a/drape/hw_texture.cpp b/drape/hw_texture.cpp
index 2fa4e7bc99..7e168258e4 100644
--- a/drape/hw_texture.cpp
+++ b/drape/hw_texture.cpp
@@ -9,10 +9,6 @@
 #include "base/logging.hpp"
 #include "base/math.hpp"
 
-#ifdef DEBUG
-#include "3party/glm/glm/gtx/bit.hpp"
-#endif
-
 #if defined(OMIM_OS_IPHONE)
 #include "drape/hw_texture_ios.hpp"
 #endif
@@ -178,10 +174,7 @@ OpenGLHWTexture::~OpenGLHWTexture()
 
 void OpenGLHWTexture::Create(Params const & params, ref_ptr<void> data)
 {
-  TBase::Create(params, data);
-
-  //ASSERT(glm::isPowerOfTwo(static_cast<int>(m_width)), (m_width));
-  //ASSERT(glm::isPowerOfTwo(static_cast<int>(m_height)), (m_height));
+  Base::Create(params, data);
 
   m_textureID = GLFunctions::glGenTexture();
   Bind();
diff --git a/drape/hw_texture.hpp b/drape/hw_texture.hpp
index 7fb1ffa1d2..0226e3b7d5 100644
--- a/drape/hw_texture.hpp
+++ b/drape/hw_texture.hpp
@@ -68,7 +68,7 @@ public:
 
 class OpenGLHWTexture : public HWTexture
 {
-  using TBase = HWTexture;
+  using Base = HWTexture;
 
 public:
   ~OpenGLHWTexture() override;
diff --git a/drape/mesh_object.cpp b/drape/mesh_object.cpp
index 3013c0a26c..236b5cae6f 100644
--- a/drape/mesh_object.cpp
+++ b/drape/mesh_object.cpp
@@ -14,9 +14,9 @@ glConst GetGLDrawPrimitive(dp::MeshObject::DrawPrimitive drawPrimitive)
 {
   switch (drawPrimitive)
   {
-    case dp::MeshObject::DrawPrimitive::Triangles: return gl_const::GLTriangles;
-    case dp::MeshObject::DrawPrimitive::TriangleStrip: return gl_const::GLTriangleStrip;
-    case dp::MeshObject::DrawPrimitive::LineStrip: return gl_const::GLLineStrip;
+  case dp::MeshObject::DrawPrimitive::Triangles: return gl_const::GLTriangles;
+  case dp::MeshObject::DrawPrimitive::TriangleStrip: return gl_const::GLTriangleStrip;
+  case dp::MeshObject::DrawPrimitive::LineStrip: return gl_const::GLLineStrip;
   }
 }
 }  // namespace
@@ -181,11 +181,11 @@ void MeshObject::Unbind(ref_ptr<dp::GpuProgram> program)
 }
 
 // static
-void MeshObject::GenerateNormalsForTriangles(std::vector<float> const & vertices, size_t componentsCount,
-                                             std::vector<float> & normals)
+std::vector<float> MeshObject::GenerateNormalsForTriangles(std::vector<float> const & vertices,
+                                                              size_t componentsCount)
 {
   auto const trianglesCount = vertices.size() / (3 * componentsCount);
-  normals.clear();
+  std::vector<float> normals;
   normals.reserve(trianglesCount * 9);
   for (size_t triangle = 0; triangle < trianglesCount; ++triangle)
   {
@@ -207,6 +207,7 @@ void MeshObject::GenerateNormalsForTriangles(std::vector<float> const & vertices
       normals.push_back(normal.z);
     }
   }
+  return normals;
 }
 }  // namespace dp
 
diff --git a/drape/mesh_object.hpp b/drape/mesh_object.hpp
index 211dbfe6a3..5d3c14bf5d 100644
--- a/drape/mesh_object.hpp
+++ b/drape/mesh_object.hpp
@@ -1,26 +1,21 @@
 #pragma once
 
-#include "drape/graphics_context.hpp"
 #include "drape/render_state.hpp"
 #include "drape/pointers.hpp"
 
 #include <functional>
+#include <string>
 #include <vector>
 
 namespace dp
 {
 class GpuProgram;
-
-class RenderParamsHolder
-{
-public:
-  virtual void ApplyProgramParams() = 0;
-};
+class GraphicsContext;
 
 class MeshObject
 {
 public:
-  enum class DrawPrimitive: uint32_t
+  enum class DrawPrimitive: uint8_t
   {
     Triangles,
     TriangleStrip,
@@ -41,7 +36,7 @@ public:
   {
     Bind(program);
 
-    ApplyState(state, context, program);
+    ApplyState(context, program, state);
     paramsSetter->Apply(program, params);
 
     DrawPrimitives();
@@ -55,8 +50,7 @@ public:
   void Build(ref_ptr<dp::GpuProgram> program);
   void Reset();
 
-  static void GenerateNormalsForTriangles(std::vector<float> const & vertices, size_t componentsCount,
-                                          std::vector<float> & normals);
+  static std::vector<float> GenerateNormalsForTriangles(std::vector<float> const & vertices, size_t componentsCount);
 
 private:
   struct AttributeMapping
diff --git a/drape/oglcontext.cpp b/drape/oglcontext.cpp
index 7543b0fbeb..62794bb176 100644
--- a/drape/oglcontext.cpp
+++ b/drape/oglcontext.cpp
@@ -9,14 +9,14 @@ glConst DecodeTestFunction(TestFunction depthFunction)
 {
   switch (depthFunction)
   {
-    case TestFunction::Never: return gl_const::GLNever;
-    case TestFunction::Less: return gl_const::GLLess;
-    case TestFunction::Equal: return gl_const::GLEqual;
-    case TestFunction::LessOrEqual: return gl_const::GLLessOrEqual;
-    case TestFunction::Greater: return gl_const::GLGreat;
-    case TestFunction::NotEqual: return gl_const::GLNotEqual;
-    case TestFunction::GreaterOrEqual: return gl_const::GLGreatOrEqual;
-    case TestFunction::Always: return gl_const::GLAlways;
+  case TestFunction::Never: return gl_const::GLNever;
+  case TestFunction::Less: return gl_const::GLLess;
+  case TestFunction::Equal: return gl_const::GLEqual;
+  case TestFunction::LessOrEqual: return gl_const::GLLessOrEqual;
+  case TestFunction::Greater: return gl_const::GLGreat;
+  case TestFunction::NotEqual: return gl_const::GLNotEqual;
+  case TestFunction::GreaterOrEqual: return gl_const::GLGreatOrEqual;
+  case TestFunction::Always: return gl_const::GLAlways;
   }
   ASSERT(false, ());
 }
@@ -25,9 +25,9 @@ glConst DecodeStencilFace(StencilFace stencilFace)
 {
   switch (stencilFace)
   {
-    case StencilFace::Front: return gl_const::GLFront;
-    case StencilFace::Back: return gl_const::GLBack;
-    case StencilFace::FrontAndBack: return gl_const::GLFrontAndBack;
+  case StencilFace::Front: return gl_const::GLFront;
+  case StencilFace::Back: return gl_const::GLBack;
+  case StencilFace::FrontAndBack: return gl_const::GLFrontAndBack;
   }
   ASSERT(false, ());
 }
@@ -36,14 +36,14 @@ glConst DecodeStencilAction(StencilAction stencilAction)
 {
   switch (stencilAction)
   {
-    case StencilAction::Keep: return gl_const::GLKeep;
-    case StencilAction::Zero: return gl_const::GLZero;
-    case StencilAction::Replace: return gl_const::GLReplace;
-    case StencilAction::Incr: return gl_const::GLIncr;
-    case StencilAction::IncrWrap: return gl_const::GLIncrWrap;
-    case StencilAction::Decr: return gl_const::GLDecr;
-    case StencilAction::DecrWrap: return gl_const::GLDecrWrap;
-    case StencilAction::Invert: return gl_const::GLInvert;
+  case StencilAction::Keep: return gl_const::GLKeep;
+  case StencilAction::Zero: return gl_const::GLZero;
+  case StencilAction::Replace: return gl_const::GLReplace;
+  case StencilAction::Increment: return gl_const::GLIncr;
+  case StencilAction::IncrementWrap: return gl_const::GLIncrWrap;
+  case StencilAction::Decrement: return gl_const::GLDecr;
+  case StencilAction::DecrementWrap: return gl_const::GLDecrWrap;
+  case StencilAction::Invert: return gl_const::GLInvert;
   }
   ASSERT(false, ());
 }
diff --git a/drape/overlay_tree.cpp b/drape/overlay_tree.cpp
index 7f44e37223..991d549309 100644
--- a/drape/overlay_tree.cpp
+++ b/drape/overlay_tree.cpp
@@ -453,7 +453,7 @@ OverlayTree::TDisplacementInfo const & OverlayTree::GetDisplacementInfo() const
   return m_displacementInfo;
 }
 
-void OverlayTree::SetDebugRectRenderer(ref_ptr<IDebugRenderer> debugRectRenderer)
+void OverlayTree::SetDebugRectRenderer(ref_ptr<DebugRenderer> debugRectRenderer)
 {
   m_debugRectRenderer = debugRectRenderer;
 }
diff --git a/drape/overlay_tree.hpp b/drape/overlay_tree.hpp
index d52b48a2d0..0ed6162849 100644
--- a/drape/overlay_tree.hpp
+++ b/drape/overlay_tree.hpp
@@ -49,7 +49,7 @@ struct OverlayHasher
 };
 }  // namespace detail
 
-class IDebugRenderer;
+class DebugRenderer;
 
 using TOverlayContainer = buffer_vector<ref_ptr<OverlayHandle>, 8>;
 
@@ -95,7 +95,7 @@ public:
   using TDisplacementInfo = std::vector<DisplacementData>;
   TDisplacementInfo const & GetDisplacementInfo() const;
 
-  void SetDebugRectRenderer(ref_ptr<IDebugRenderer> debugRectRenderer);
+  void SetDebugRectRenderer(ref_ptr<DebugRenderer> debugRectRenderer);
 
 private:
   ScreenBase const & GetModelView() const { return m_traits.GetModelView(); }
@@ -119,7 +119,7 @@ private:
   FeatureID m_selectedFeatureID;
 
   TDisplacementInfo m_displacementInfo;
-  ref_ptr<IDebugRenderer> m_debugRectRenderer;
+  ref_ptr<DebugRenderer> m_debugRectRenderer;
 
   HandlesCache m_displacers;
   uint32_t m_frameUpdatePeriod;
diff --git a/drape/render_bucket.cpp b/drape/render_bucket.cpp
index 8682278b48..c4f5567846 100644
--- a/drape/render_bucket.cpp
+++ b/drape/render_bucket.cpp
@@ -133,8 +133,8 @@ void RenderBucket::SetFeatureMinZoom(int minZoom)
     m_featuresMinZoom = minZoom;
 }
 
-void RenderBucket::RenderDebug(ScreenBase const & screen, ref_ptr<GraphicsContext> context,
-                               ref_ptr<IDebugRenderer> debugRectRenderer) const
+void RenderBucket::RenderDebug(ref_ptr<GraphicsContext> context, ScreenBase const & screen,
+                               ref_ptr<DebugRenderer> debugRectRenderer) const
 {
   if (!debugRectRenderer || !debugRectRenderer->IsEnabled() || m_overlay.empty())
     return;
diff --git a/drape/render_bucket.hpp b/drape/render_bucket.hpp
index faab8425e3..0ef6ce50e6 100644
--- a/drape/render_bucket.hpp
+++ b/drape/render_bucket.hpp
@@ -17,7 +17,7 @@ namespace dp
 {
 
 class GraphicsContext;
-class IDebugRenderer;
+class DebugRenderer;
 class OverlayHandle;
 class OverlayTree;
 class VertexArrayBuffer;
@@ -45,8 +45,8 @@ public:
   void Render(bool drawAsLine);
 
   // Only for testing! Don't use this function in production code!
-  void RenderDebug(ScreenBase const & screen, ref_ptr<GraphicsContext> context,
-                   ref_ptr<IDebugRenderer> debugRectRenderer) const;
+  void RenderDebug(ref_ptr<GraphicsContext> context, ScreenBase const & screen,
+                   ref_ptr<DebugRenderer> debugRectRenderer) const;
 
   // Only for testing! Don't use this function in production code!
   template <typename ToDo>
diff --git a/drape/render_state.cpp b/drape/render_state.cpp
index 93ea2a52f1..a6efc153b7 100644
--- a/drape/render_state.cpp
+++ b/drape/render_state.cpp
@@ -14,14 +14,14 @@ glConst DecodeTestFunction(TestFunction depthFunction)
 {
   switch (depthFunction)
   {
-    case TestFunction::Never: return gl_const::GLNever;
-    case TestFunction::Less: return gl_const::GLLess;
-    case TestFunction::Equal: return gl_const::GLEqual;
-    case TestFunction::LessOrEqual: return gl_const::GLLessOrEqual;
-    case TestFunction::Greater: return gl_const::GLGreat;
-    case TestFunction::NotEqual: return gl_const::GLNotEqual;
-    case TestFunction::GreaterOrEqual: return gl_const::GLGreatOrEqual;
-    case TestFunction::Always: return gl_const::GLAlways;
+  case TestFunction::Never: return gl_const::GLNever;
+  case TestFunction::Less: return gl_const::GLLess;
+  case TestFunction::Equal: return gl_const::GLEqual;
+  case TestFunction::LessOrEqual: return gl_const::GLLessOrEqual;
+  case TestFunction::Greater: return gl_const::GLGreat;
+  case TestFunction::NotEqual: return gl_const::GLNotEqual;
+  case TestFunction::GreaterOrEqual: return gl_const::GLGreatOrEqual;
+  case TestFunction::Always: return gl_const::GLAlways;
   }
   CHECK_SWITCH();
 }
@@ -215,7 +215,7 @@ void ApplyBlending(RenderState const & state)
   state.GetBlending().Apply();
 }
 
-void ApplyState(RenderState const & state, ref_ptr<GraphicsContext> context, ref_ptr<GpuProgram> program)
+void ApplyState(ref_ptr<GraphicsContext> context, ref_ptr<GpuProgram> program, RenderState const & state)
 {
   TextureState::ApplyTextures(state, program);
   ApplyBlending(state);
diff --git a/drape/render_state.hpp b/drape/render_state.hpp
index 27bb0a74d9..485ea1fb81 100644
--- a/drape/render_state.hpp
+++ b/drape/render_state.hpp
@@ -123,6 +123,6 @@ private:
   static uint8_t m_usedSlots;
 };
 
-void ApplyState(RenderState const & state, ref_ptr<GraphicsContext> context, ref_ptr<GpuProgram> program);
+void ApplyState(ref_ptr<GraphicsContext> context, ref_ptr<GpuProgram> program, RenderState const & state);
 void ApplyBlending(RenderState const & state);
 }  // namespace dp
diff --git a/drape/static_texture.cpp b/drape/static_texture.cpp
index 3121088433..e51609ee12 100644
--- a/drape/static_texture.cpp
+++ b/drape/static_texture.cpp
@@ -142,6 +142,20 @@ ref_ptr<Texture::ResourceInfo> StaticTexture::FindResource(Texture::Key const &
   return make_ref(m_info);
 }
 
+void StaticTexture::Create(Params const & params)
+{
+  ASSERT(Base::IsPowerOfTwo(params.m_width, params.m_height), (params.m_width, params.m_height));
+
+  Base::Create(params);
+}
+
+void StaticTexture::Create(Params const & params, ref_ptr<void> data)
+{
+  ASSERT(Base::IsPowerOfTwo(params.m_width, params.m_height), (params.m_width, params.m_height));
+
+  Base::Create(params, data);
+}
+
 void StaticTexture::Fail()
 {
   int32_t alphaTexture = 0;
diff --git a/drape/static_texture.hpp b/drape/static_texture.hpp
index d7a6950445..8175a4d2fc 100644
--- a/drape/static_texture.hpp
+++ b/drape/static_texture.hpp
@@ -8,6 +8,7 @@ namespace dp
 {
 class StaticTexture : public Texture
 {
+  using Base = Texture;
 public:
   class StaticKey : public Key
   {
@@ -21,6 +22,8 @@ public:
                 dp::TextureFormat format, ref_ptr<HWTextureAllocator> allocator);
 
   ref_ptr<ResourceInfo> FindResource(Key const & key, bool & newResource) override;
+  void Create(Params const & params) override;
+  void Create(Params const & params, ref_ptr<void> data) override;
 
   void Invalidate(ref_ptr<HWTextureAllocator> allocator);
 
diff --git a/drape/texture.cpp b/drape/texture.cpp
index b09e35b180..3eb0156175 100644
--- a/drape/texture.cpp
+++ b/drape/texture.cpp
@@ -2,10 +2,13 @@
 
 #include "drape/glextensions_list.hpp"
 #include "drape/glfunctions.hpp"
+#include "drape/glsl_func.hpp"
 #include "drape/utils/gpu_mem_tracker.hpp"
 
 #include "base/math.hpp"
 
+#include "3party/glm/glm/gtx/bit.hpp"
+
 namespace dp
 {
 Texture::ResourceInfo::ResourceInfo(m2::RectF const & texRect) : m_texRect(texRect) {}
@@ -83,11 +86,18 @@ void Texture::SetFilter(TextureFilter filter)
   m_hwTexture->SetFilter(filter);
 }
 
+// static
 uint32_t Texture::GetMaxTextureSize()
 {
   return static_cast<uint32_t>(GLFunctions::glGetInteger(gl_const::GLMaxTextureSize));
 }
 
+// static
+bool Texture::IsPowerOfTwo(uint32_t width, uint32_t height)
+{
+  return glm::isPowerOfTwo(static_cast<int>(width)) && glm::isPowerOfTwo(static_cast<int>(height));
+}
+
 void Texture::Destroy() { m_hwTexture.reset(); }
 
 bool Texture::AllocateTexture(ref_ptr<HWTextureAllocator> allocator)
diff --git a/drape/texture.hpp b/drape/texture.hpp
index 679eb121c5..8dff145036 100644
--- a/drape/texture.hpp
+++ b/drape/texture.hpp
@@ -64,11 +64,12 @@ public:
   // Texture must be bound before calling this method.
   virtual void SetFilter(TextureFilter filter);
 
-  void Create(Params const & params);
-  void Create(Params const & params, ref_ptr<void> data);
+  virtual void Create(Params const & params);
+  virtual void Create(Params const & params, ref_ptr<void> data);
   void UploadData(uint32_t x, uint32_t y, uint32_t width, uint32_t height, ref_ptr<void> data);
 
   static uint32_t GetMaxTextureSize();
+  static bool IsPowerOfTwo(uint32_t width, uint32_t height);
 
 protected:
   void Destroy();
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;
diff --git a/xcode/drape/drape.xcodeproj/project.pbxproj b/xcode/drape/drape.xcodeproj/project.pbxproj
index accab9d453..e8c2461cf5 100644
--- a/xcode/drape/drape.xcodeproj/project.pbxproj
+++ b/xcode/drape/drape.xcodeproj/project.pbxproj
@@ -7,8 +7,6 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
-		347F32F91C45383E009758CC /* debug_rect_renderer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 347F32F71C45383E009758CC /* debug_rect_renderer.cpp */; };
-		347F32FA1C45383E009758CC /* debug_rect_renderer.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 347F32F81C45383E009758CC /* debug_rect_renderer.hpp */; };
 		3492DA0B1CA2D91C00C1F3B3 /* visual_scale.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3492DA0A1CA2D91C00C1F3B3 /* visual_scale.hpp */; };
 		34C624C91DABDB2000510300 /* static_texture.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 34C624C71DABDB2000510300 /* static_texture.cpp */; };
 		34C624CA1DABDB2000510300 /* static_texture.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 34C624C81DABDB2000510300 /* static_texture.hpp */; };
@@ -106,6 +104,7 @@
 		675D21991BFB876E00717E4F /* projection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 675D21971BFB876E00717E4F /* projection.cpp */; };
 		675D219A1BFB876E00717E4F /* projection.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 675D21981BFB876E00717E4F /* projection.hpp */; };
 		BB035F6C1E3A2A5C00519962 /* drape_diagnostics.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BB035F6B1E3A2A5C00519962 /* drape_diagnostics.hpp */; };
+		BBAD59F821258812005543FC /* debug_renderer.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BBAD59F721258812005543FC /* debug_renderer.hpp */; };
 		BBB72E902110AF0F00249D4F /* oglcontext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BBB72E8F2110AF0F00249D4F /* oglcontext.cpp */; };
 		BBB72E9A2111CE9100249D4F /* graphics_context.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BBB72E972111CE9100249D4F /* graphics_context.hpp */; };
 		BBB72E9B2111CE9100249D4F /* graphics_context_factory.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BBB72E982111CE9100249D4F /* graphics_context_factory.hpp */; };
@@ -115,8 +114,6 @@
 /* End PBXBuildFile section */
 
 /* Begin PBXFileReference section */
-		347F32F71C45383E009758CC /* debug_rect_renderer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = debug_rect_renderer.cpp; sourceTree = "<group>"; };
-		347F32F81C45383E009758CC /* debug_rect_renderer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = debug_rect_renderer.hpp; sourceTree = "<group>"; };
 		3492DA0A1CA2D91C00C1F3B3 /* visual_scale.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = visual_scale.hpp; sourceTree = "<group>"; };
 		34AF87C91DBE4F4900E5E7DC /* common-debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = "common-debug.xcconfig"; path = "../common-debug.xcconfig"; sourceTree = "<group>"; };
 		34AF87CA1DBE4F4900E5E7DC /* common-release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = "common-release.xcconfig"; path = "../common-release.xcconfig"; sourceTree = "<group>"; };
@@ -217,6 +214,7 @@
 		675D21971BFB876E00717E4F /* projection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = projection.cpp; sourceTree = "<group>"; };
 		675D21981BFB876E00717E4F /* projection.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = projection.hpp; sourceTree = "<group>"; };
 		BB035F6B1E3A2A5C00519962 /* drape_diagnostics.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = drape_diagnostics.hpp; sourceTree = "<group>"; };
+		BBAD59F721258812005543FC /* debug_renderer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = debug_renderer.hpp; sourceTree = "<group>"; };
 		BBB72E8F2110AF0F00249D4F /* oglcontext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = oglcontext.cpp; sourceTree = "<group>"; };
 		BBB72E972111CE9100249D4F /* graphics_context.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = graphics_context.hpp; sourceTree = "<group>"; };
 		BBB72E982111CE9100249D4F /* graphics_context_factory.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = graphics_context_factory.hpp; sourceTree = "<group>"; };
@@ -279,8 +277,7 @@
 				670947151BDF9A4F005014C0 /* data_buffer_impl.hpp */,
 				6729A50F1A69213A007D5872 /* data_buffer.cpp */,
 				6729A5101A69213A007D5872 /* data_buffer.hpp */,
-				347F32F71C45383E009758CC /* debug_rect_renderer.cpp */,
-				347F32F81C45383E009758CC /* debug_rect_renderer.hpp */,
+				BBAD59F721258812005543FC /* debug_renderer.hpp */,
 				BB035F6B1E3A2A5C00519962 /* drape_diagnostics.hpp */,
 				6729A5111A69213A007D5872 /* drape_global.hpp */,
 				457B536320358F7D00E4E752 /* drape_routine.hpp */,
@@ -393,13 +390,13 @@
 				3492DA0B1CA2D91C00C1F3B3 /* visual_scale.hpp in Headers */,
 				6729A5971A69213A007D5872 /* overlay_tree.hpp in Headers */,
 				6729A5751A69213A007D5872 /* drape_global.hpp in Headers */,
-				347F32FA1C45383E009758CC /* debug_rect_renderer.hpp in Headers */,
 				6729A5701A69213A007D5872 /* color.hpp in Headers */,
 				6729A5801A69213A007D5872 /* glsl_func.hpp in Headers */,
 				6729A5761A69213A007D5872 /* dynamic_texture.hpp in Headers */,
 				45D7ADE22113535600160DE3 /* render_state.hpp in Headers */,
 				6729A5681A69213A007D5872 /* batcher_helpers.hpp in Headers */,
 				6729A56A1A69213A007D5872 /* batcher.hpp in Headers */,
+				BBAD59F821258812005543FC /* debug_renderer.hpp in Headers */,
 				45447109211462A300D28C28 /* texture_types.hpp in Headers */,
 				BBB72EA02118A45800249D4F /* mesh_object.hpp in Headers */,
 				675D219A1BFB876E00717E4F /* projection.hpp in Headers */,
@@ -534,7 +531,6 @@
 				BBB72E9C2111CE9100249D4F /* graphics_context_factory.cpp in Sources */,
 				6729A5771A69213A007D5872 /* font_texture.cpp in Sources */,
 				45D7ADE32113535600160DE3 /* render_state.cpp in Sources */,
-				347F32F91C45383E009758CC /* debug_rect_renderer.cpp in Sources */,
 				6729A58E1A69213A007D5872 /* index_buffer.cpp in Sources */,
 				6729A5A61A69213A007D5872 /* texture_manager.cpp in Sources */,
 				670947271BDF9A4F005014C0 /* glyph_manager.cpp in Sources */,
diff --git a/xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj b/xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj
index cf604bb14f..150232a8e3 100644
--- a/xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj
+++ b/xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj
@@ -196,6 +196,8 @@
 		BB7D67D21F34A62C002FD122 /* custom_features_context.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BB7D67CF1F34A62C002FD122 /* custom_features_context.hpp */; };
 		BB7D67D31F34A62C002FD122 /* path_text_handle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BB7D67D01F34A62C002FD122 /* path_text_handle.cpp */; };
 		BB7D67D41F34A62C002FD122 /* path_text_handle.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BB7D67D11F34A62C002FD122 /* path_text_handle.hpp */; };
+		BBAD59FB21258843005543FC /* debug_rect_renderer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BBAD59F921258841005543FC /* debug_rect_renderer.cpp */; };
+		BBAD59FC21258843005543FC /* debug_rect_renderer.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BBAD59FA21258842005543FC /* debug_rect_renderer.hpp */; };
 		BBD8F8791E96A51A00BAEB72 /* drape_hints.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BBD8F8781E96A51A00BAEB72 /* drape_hints.hpp */; };
 		BBD9E2D31F009D9E00DF189A /* user_mark_generator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BBD9E2D11F009D9E00DF189A /* user_mark_generator.cpp */; };
 		BBD9E2D41F009D9E00DF189A /* user_mark_generator.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BBD9E2D21F009D9E00DF189A /* user_mark_generator.hpp */; };
@@ -468,6 +470,8 @@
 		BB7D67CF1F34A62C002FD122 /* custom_features_context.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = custom_features_context.hpp; sourceTree = "<group>"; };
 		BB7D67D01F34A62C002FD122 /* path_text_handle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = path_text_handle.cpp; sourceTree = "<group>"; };
 		BB7D67D11F34A62C002FD122 /* path_text_handle.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = path_text_handle.hpp; sourceTree = "<group>"; };
+		BBAD59F921258841005543FC /* debug_rect_renderer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = debug_rect_renderer.cpp; sourceTree = "<group>"; };
+		BBAD59FA21258842005543FC /* debug_rect_renderer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = debug_rect_renderer.hpp; sourceTree = "<group>"; };
 		BBD8F8781E96A51A00BAEB72 /* drape_hints.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = drape_hints.hpp; sourceTree = "<group>"; };
 		BBD9E2D11F009D9E00DF189A /* user_mark_generator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = user_mark_generator.cpp; sourceTree = "<group>"; };
 		BBD9E2D21F009D9E00DF189A /* user_mark_generator.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = user_mark_generator.hpp; sourceTree = "<group>"; };
@@ -609,6 +613,8 @@
 				453EEA6B1E3A28F400505E09 /* colored_symbol_shape.cpp */,
 				453EEA6C1E3A28F400505E09 /* colored_symbol_shape.hpp */,
 				BB7D67CF1F34A62C002FD122 /* custom_features_context.hpp */,
+				BBAD59F921258841005543FC /* debug_rect_renderer.cpp */,
+				BBAD59FA21258842005543FC /* debug_rect_renderer.hpp */,
 				347F52071DC2334A0064B273 /* drape_api_builder.cpp */,
 				347F52081DC2334A0064B273 /* drape_api_builder.hpp */,
 				347F52091DC2334A0064B273 /* drape_api_renderer.cpp */,
@@ -823,6 +829,7 @@
 				670948031BDF9BF5005014C0 /* drape_engine.hpp in Headers */,
 				670948191BDF9C39005014C0 /* interpolations.hpp in Headers */,
 				456B3F9A1ED464FE009B3D1F /* postprocess_renderer.hpp in Headers */,
+				BBAD59FC21258843005543FC /* debug_rect_renderer.hpp in Headers */,
 				670947CB1BDF9BE1005014C0 /* threads_commutator.hpp in Headers */,
 				347F52121DC2334A0064B273 /* drape_api.hpp in Headers */,
 				452C9EDF1CEDCF3200A55E57 /* parallel_animation.hpp in Headers */,
@@ -1007,6 +1014,7 @@
 				453EEA6D1E3A28F400505E09 /* colored_symbol_shape.cpp in Sources */,
 				670947921BDF9BE1005014C0 /* kinetic_scroller.cpp in Sources */,
 				45D7ADDF2113532700160DE3 /* render_state_extension.cpp in Sources */,
+				BBAD59FB21258843005543FC /* debug_rect_renderer.cpp in Sources */,
 				6709484D1BDF9C48005014C0 /* shape.cpp in Sources */,
 				670948431BDF9C48005014C0 /* drape_gui.cpp in Sources */,
 				670947D61BDF9BE1005014C0 /* user_event_stream.cpp in Sources */,
author	Daria Volvenkova <d.volvenkova@corp.mail.ru>	2018-08-16 18:48:20 +0300
committer	Roman Kuznetsov <r.kuznetsow@gmail.com>	2018-08-17 13:11:53 +0300
commit	04c0ffbab4df4bee1e229474787b98feb4d6ae06 (patch)
tree	702742ea61542b85e400e7aa34540d7894dd93de
parent	5ab189afac15e9e97aef702e69e0d883bc8532b9 (diff)