Renamed GLState

78 files changed, 429 insertions, 430 deletions

diff --git a/drape/CMakeLists.txt b/drape/CMakeLists.txt
index efa16b2c14..476bfd8ed3 100644
--- a/drape/CMakeLists.txt
+++ b/drape/CMakeLists.txt
@@ -53,8 +53,6 @@ set(
   ${DRAPE_ROOT}/glIncludes.hpp
   ${DRAPE_ROOT}/glsl_func.hpp
   ${DRAPE_ROOT}/glsl_types.hpp
-  ${DRAPE_ROOT}/glstate.cpp
-  ${DRAPE_ROOT}/glstate.hpp
   ${DRAPE_ROOT}/glyph_generator.cpp
   ${DRAPE_ROOT}/glyph_generator.hpp
   ${DRAPE_ROOT}/glyph_manager.cpp
@@ -85,6 +83,8 @@ set(
   ${DRAPE_ROOT}/pointers.hpp
   ${DRAPE_ROOT}/render_bucket.cpp
   ${DRAPE_ROOT}/render_bucket.hpp
+  ${DRAPE_ROOT}/render_state.cpp
+  ${DRAPE_ROOT}/render_state.hpp
   ${DRAPE_ROOT}/shader.cpp
   ${DRAPE_ROOT}/shader.hpp
   ${DRAPE_ROOT}/static_texture.cpp
diff --git a/drape/batcher.cpp b/drape/batcher.cpp
index f5e75ed1f8..4b7b6b8b76 100644
--- a/drape/batcher.cpp
+++ b/drape/batcher.cpp
@@ -16,7 +16,7 @@ namespace dp
 class Batcher::CallbacksWrapper : public BatchCallbacks
 {
 public:
-  CallbacksWrapper(GLState const & state, ref_ptr<OverlayHandle> overlay, ref_ptr<Batcher> batcher)
+  CallbacksWrapper(RenderState const & state, ref_ptr<OverlayHandle> overlay, ref_ptr<Batcher> batcher)
     : m_state(state)
     , m_overlay(overlay)
     , m_batcher(batcher)
@@ -79,7 +79,7 @@ public:
     m_batcher->ChangeBuffer(make_ref(this));
   }
 
-  GLState const & GetState() const
+  RenderState const & GetState() const
   {
     return m_state;
   }
@@ -95,7 +95,7 @@ public:
   }
 
 private:
-  GLState const & m_state;
+  RenderState const & m_state;
   ref_ptr<OverlayHandle> m_overlay;
   ref_ptr<Batcher> m_batcher;
   ref_ptr<VertexArrayBuffer> m_buffer;
@@ -114,69 +114,69 @@ Batcher::~Batcher()
   m_buckets.clear();
 }
 
-void Batcher::InsertTriangleList(GLState const & state, ref_ptr<AttributeProvider> params)
+void Batcher::InsertTriangleList(RenderState const & state, ref_ptr<AttributeProvider> params)
 {
   InsertTriangleList(state, params, nullptr);
 }
 
-IndicesRange Batcher::InsertTriangleList(GLState const & state, ref_ptr<AttributeProvider> params,
+IndicesRange Batcher::InsertTriangleList(RenderState const & state, ref_ptr<AttributeProvider> params,
                                          drape_ptr<OverlayHandle> && handle)
 {
   return InsertPrimitives<TriangleListBatch>(state, params, move(handle), 0 /* vertexStride */);
 }
 
-void Batcher::InsertTriangleStrip(GLState const & state, ref_ptr<AttributeProvider> params)
+void Batcher::InsertTriangleStrip(RenderState const & state, ref_ptr<AttributeProvider> params)
 {
   InsertTriangleStrip(state, params, nullptr);
 }
 
-IndicesRange Batcher::InsertTriangleStrip(GLState const & state, ref_ptr<AttributeProvider> params,
+IndicesRange Batcher::InsertTriangleStrip(RenderState const & state, ref_ptr<AttributeProvider> params,
                                           drape_ptr<OverlayHandle> && handle)
 {
   return InsertPrimitives<TriangleStripBatch>(state, params, move(handle), 0 /* vertexStride */);
 }
 
-void Batcher::InsertTriangleFan(GLState const & state, ref_ptr<AttributeProvider> params)
+void Batcher::InsertTriangleFan(RenderState const & state, ref_ptr<AttributeProvider> params)
 {
   InsertTriangleFan(state, params, nullptr);
 }
 
-IndicesRange Batcher::InsertTriangleFan(GLState const & state, ref_ptr<AttributeProvider> params,
+IndicesRange Batcher::InsertTriangleFan(RenderState const & state, ref_ptr<AttributeProvider> params,
                                         drape_ptr<OverlayHandle> && handle)
 {
   return InsertPrimitives<TriangleFanBatch>(state, params, move(handle), 0 /* vertexStride */);
 }
 
-void Batcher::InsertListOfStrip(GLState const & state, ref_ptr<AttributeProvider> params,
+void Batcher::InsertListOfStrip(RenderState const & state, ref_ptr<AttributeProvider> params,
                                 uint8_t vertexStride)
 {
   InsertListOfStrip(state, params, nullptr, vertexStride);
 }
 
-IndicesRange Batcher::InsertListOfStrip(GLState const & state, ref_ptr<AttributeProvider> params,
+IndicesRange Batcher::InsertListOfStrip(RenderState const & state, ref_ptr<AttributeProvider> params,
                                         drape_ptr<OverlayHandle> && handle, uint8_t vertexStride)
 {
   return InsertPrimitives<TriangleListOfStripBatch>(state, params, move(handle), vertexStride);
 }
 
-void Batcher::InsertLineStrip(GLState const & state, ref_ptr<AttributeProvider> params)
+void Batcher::InsertLineStrip(RenderState const & state, ref_ptr<AttributeProvider> params)
 {
   InsertLineStrip(state, params, nullptr);
 }
 
-IndicesRange Batcher::InsertLineStrip(GLState const & state, ref_ptr<AttributeProvider> params,
+IndicesRange Batcher::InsertLineStrip(RenderState const & state, ref_ptr<AttributeProvider> params,
                                       drape_ptr<OverlayHandle> && handle)
 {
   return InsertPrimitives<LineStripBatch>(state, params, move(handle), 0 /* vertexStride */);
 }
 
-void Batcher::InsertLineRaw(GLState const & state, ref_ptr<AttributeProvider> params,
+void Batcher::InsertLineRaw(RenderState const & state, ref_ptr<AttributeProvider> params,
                             vector<int> const & indices)
 {
   InsertLineRaw(state, params, indices, nullptr);
 }
 
-IndicesRange Batcher::InsertLineRaw(GLState const & state, ref_ptr<AttributeProvider> params,
+IndicesRange Batcher::InsertLineRaw(RenderState const & state, ref_ptr<AttributeProvider> params,
                                     vector<int> const & indices, drape_ptr<OverlayHandle> && handle)
 {
   return InsertPrimitives<LineRawBatch>(state, params, move(handle), 0 /* vertexStride */, indices);
@@ -209,14 +209,14 @@ void Batcher::SetFeatureMinZoom(int minZoom)
 
 void Batcher::ChangeBuffer(ref_ptr<CallbacksWrapper> wrapper)
 {
-  GLState const & state = wrapper->GetState();
+  RenderState const & state = wrapper->GetState();
   FinalizeBucket(state);
 
   ref_ptr<RenderBucket> bucket = GetBucket(state);
   wrapper->SetVAO(bucket->GetBuffer());
 }
 
-ref_ptr<RenderBucket> Batcher::GetBucket(GLState const & state)
+ref_ptr<RenderBucket> Batcher::GetBucket(RenderState const & state)
 {
   TBuckets::iterator it = m_buckets.find(state);
   if (it != m_buckets.end())
@@ -232,7 +232,7 @@ ref_ptr<RenderBucket> Batcher::GetBucket(GLState const & state)
   return result;
 }
 
-void Batcher::FinalizeBucket(GLState const & state)
+void Batcher::FinalizeBucket(RenderState const & state)
 {
   TBuckets::iterator it = m_buckets.find(state);
   ASSERT(it != m_buckets.end(), ("Have no bucket for finalize with given state"));
@@ -257,7 +257,7 @@ void Batcher::Flush()
 }
 
 template <typename TBatcher, typename ... TArgs>
-IndicesRange Batcher::InsertPrimitives(GLState const & state, ref_ptr<AttributeProvider> params,
+IndicesRange Batcher::InsertPrimitives(RenderState const & state, ref_ptr<AttributeProvider> params,
                                        drape_ptr<OverlayHandle> && transferHandle, uint8_t vertexStride,
                                        TArgs ... batcherArgs)
 {
diff --git a/drape/batcher.hpp b/drape/batcher.hpp
index e3db046245..3f4ecf714b 100644
--- a/drape/batcher.hpp
+++ b/drape/batcher.hpp
@@ -1,10 +1,10 @@
 #pragma once
 
 #include "drape/attribute_provider.hpp"
-#include "drape/glstate.hpp"
 #include "drape/overlay_handle.hpp"
 #include "drape/pointers.hpp"
 #include "drape/render_bucket.hpp"
+#include "drape/render_state.hpp"
 #include "drape/vertex_array_buffer.hpp"
 
 #include "base/macros.hpp"
@@ -28,32 +28,32 @@ public:
   Batcher(uint32_t indexBufferSize, uint32_t vertexBufferSize);
   ~Batcher();
 
-  void InsertTriangleList(GLState const & state, ref_ptr<AttributeProvider> params);
-  IndicesRange InsertTriangleList(GLState const & state, ref_ptr<AttributeProvider> params,
+  void InsertTriangleList(RenderState const & state, ref_ptr<AttributeProvider> params);
+  IndicesRange InsertTriangleList(RenderState const & state, ref_ptr<AttributeProvider> params,
                                   drape_ptr<OverlayHandle> && handle);
 
-  void InsertTriangleStrip(GLState const & state, ref_ptr<AttributeProvider> params);
-  IndicesRange InsertTriangleStrip(GLState const & state, ref_ptr<AttributeProvider> params,
+  void InsertTriangleStrip(RenderState const & state, ref_ptr<AttributeProvider> params);
+  IndicesRange InsertTriangleStrip(RenderState const & state, ref_ptr<AttributeProvider> params,
                                    drape_ptr<OverlayHandle> && handle);
 
-  void InsertTriangleFan(GLState const & state, ref_ptr<AttributeProvider> params);
-  IndicesRange InsertTriangleFan(GLState const & state, ref_ptr<AttributeProvider> params,
+  void InsertTriangleFan(RenderState const & state, ref_ptr<AttributeProvider> params);
+  IndicesRange InsertTriangleFan(RenderState const & state, ref_ptr<AttributeProvider> params,
                                  drape_ptr<OverlayHandle> && handle);
 
-  void InsertListOfStrip(GLState const & state, ref_ptr<AttributeProvider> params, uint8_t vertexStride);
-  IndicesRange InsertListOfStrip(GLState const & state, ref_ptr<AttributeProvider> params,
+  void InsertListOfStrip(RenderState const & state, ref_ptr<AttributeProvider> params, uint8_t vertexStride);
+  IndicesRange InsertListOfStrip(RenderState const & state, ref_ptr<AttributeProvider> params,
                                  drape_ptr<OverlayHandle> && handle, uint8_t vertexStride);
 
-  void InsertLineStrip(GLState const & state, ref_ptr<AttributeProvider> params);
-  IndicesRange InsertLineStrip(GLState const & state, ref_ptr<AttributeProvider> params,
+  void InsertLineStrip(RenderState const & state, ref_ptr<AttributeProvider> params);
+  IndicesRange InsertLineStrip(RenderState const & state, ref_ptr<AttributeProvider> params,
                                drape_ptr<OverlayHandle> && handle);
 
-  void InsertLineRaw(GLState const & state, ref_ptr<AttributeProvider> params,
+  void InsertLineRaw(RenderState const & state, ref_ptr<AttributeProvider> params,
                      vector<int> const & indices);
-  IndicesRange InsertLineRaw(GLState const & state, ref_ptr<AttributeProvider> params,
+  IndicesRange InsertLineRaw(RenderState const & state, ref_ptr<AttributeProvider> params,
                              vector<int> const & indices, drape_ptr<OverlayHandle> && handle);
 
-  typedef function<void (GLState const &, drape_ptr<RenderBucket> &&)> TFlushFn;
+  typedef function<void (RenderState const &, drape_ptr<RenderBucket> &&)> TFlushFn;
   void StartSession(TFlushFn const & flusher);
   void EndSession();
   void ResetSession();
@@ -62,20 +62,20 @@ public:
 
 private:
   template<typename TBatcher, typename ... TArgs>
-  IndicesRange InsertPrimitives(GLState const & state, ref_ptr<AttributeProvider> params,
+  IndicesRange InsertPrimitives(RenderState const & state, ref_ptr<AttributeProvider> params,
                                 drape_ptr<OverlayHandle> && transferHandle, uint8_t vertexStride,
                                 TArgs ... batcherArgs);
 
   class CallbacksWrapper;
   void ChangeBuffer(ref_ptr<CallbacksWrapper> wrapper);
-  ref_ptr<RenderBucket> GetBucket(GLState const & state);
+  ref_ptr<RenderBucket> GetBucket(RenderState const & state);
 
-  void FinalizeBucket(GLState const & state);
+  void FinalizeBucket(RenderState const & state);
   void Flush();
 
   TFlushFn m_flushInterface;
 
-  using TBuckets = map<GLState, drape_ptr<RenderBucket>>;
+  using TBuckets = map<RenderState, drape_ptr<RenderBucket>>;
   TBuckets m_buckets;
 
   uint32_t m_indexBufferSize;
diff --git a/drape/drape_tests/batcher_tests.cpp b/drape/drape_tests/batcher_tests.cpp
index dac7ea49b7..8b4ae0f489 100644
--- a/drape/drape_tests/batcher_tests.cpp
+++ b/drape/drape_tests/batcher_tests.cpp
@@ -28,7 +28,7 @@ namespace
 {
 struct VAOAcceptor
 {
-  virtual void FlushFullBucket(GLState const & /*state*/, drape_ptr<RenderBucket> && bucket)
+  virtual void FlushFullBucket(RenderState const & /*state*/, drape_ptr<RenderBucket> && bucket)
   {
     m_vao.push_back(move(bucket));
   }
@@ -36,11 +36,11 @@ struct VAOAcceptor
   std::vector<drape_ptr<RenderBucket>> m_vao;
 };
 
-class TestRenderState : public dp::BaseRenderState
+class TestExtension : public dp::BaseRenderStateExtension
 {
 public:
-  bool Less(ref_ptr<dp::BaseRenderState> other) const override { return false; }
-  bool Equal(ref_ptr<dp::BaseRenderState> other) const override { return true; }
+  bool Less(ref_ptr<dp::BaseRenderStateExtension> other) const override { return false; }
+  bool Equal(ref_ptr<dp::BaseRenderStateExtension> other) const override { return true; }
 };
 
 class BatcherExpectations
@@ -62,8 +62,8 @@ public:
 
     ExpectBufferCreation(vertexSize, indexCount, indexCmp, dataCmp);
 
-    auto renderState = make_unique_dp<TestRenderState>();
-    auto state = GLState(0, make_ref(renderState));
+    auto renderState = make_unique_dp<TestExtension>();
+    auto state = RenderState(0, make_ref(renderState));
 
     BindingInfo binding(1);
     BindingDecl & decl = binding.GetBindingDecl(0);
@@ -141,7 +141,7 @@ UNIT_TEST(BatchLists_Test)
   dp::IndexStorage indexes(std::move(indexesRaw));
 
   BatcherExpectations expectations;
-  auto fn = [](Batcher * batcher, GLState const & state, ref_ptr<AttributeProvider> p)
+  auto fn = [](Batcher * batcher, RenderState const & state, ref_ptr<AttributeProvider> p)
   {
     batcher->InsertTriangleList(state, p);
   };
@@ -161,7 +161,7 @@ UNIT_TEST(BatchListOfStript_4stride)
   dp::IndexStorage indexes(std::move(indexesRaw));
 
   BatcherExpectations expectations;
-  auto fn = [](Batcher * batcher, GLState const & state, ref_ptr<AttributeProvider> p)
+  auto fn = [](Batcher * batcher, RenderState const & state, ref_ptr<AttributeProvider> p)
   {
     batcher->InsertListOfStrip(state, p, dp::Batcher::VertexPerQuad);
   };
@@ -192,7 +192,7 @@ UNIT_TEST(BatchListOfStript_5stride)
   dp::IndexStorage indexes(std::move(indexesRaw));
 
   BatcherExpectations expectations;
-  auto fn = [](Batcher * batcher, GLState const & state, ref_ptr<AttributeProvider> p)
+  auto fn = [](Batcher * batcher, RenderState const & state, ref_ptr<AttributeProvider> p)
   {
     batcher->InsertListOfStrip(state, p, 5);
   };
@@ -226,7 +226,7 @@ UNIT_TEST(BatchListOfStript_6stride)
   dp::IndexStorage indexes(std::move(indexesRaw));
 
   BatcherExpectations expectations;
-  auto fn = [](Batcher * batcher, GLState const & state, ref_ptr<AttributeProvider> p)
+  auto fn = [](Batcher * batcher, RenderState const & state, ref_ptr<AttributeProvider> p)
   {
     batcher->InsertListOfStrip(state, p, 6);
   };
@@ -371,8 +371,8 @@ UNIT_TEST(BatchListOfStript_partial)
     test.AddBufferNode(node2);
     test.CloseExpection();
 
-    auto renderState = make_unique_dp<TestRenderState>();
-    auto state = GLState(0, make_ref(renderState));
+    auto renderState = make_unique_dp<TestExtension>();
+    auto state = RenderState(0, make_ref(renderState));
 
     BindingInfo binding(1);
     BindingDecl & decl = binding.GetBindingDecl(0);
diff --git a/drape/gpu_program.cpp b/drape/gpu_program.cpp
index 0b3b949a5a..2ce44807d7 100644
--- a/drape/gpu_program.cpp
+++ b/drape/gpu_program.cpp
@@ -1,6 +1,6 @@
 #include "drape/gpu_program.hpp"
 #include "drape/glfunctions.hpp"
-#include "drape/glstate.hpp"
+#include "drape/render_state.hpp"
 #include "drape/support_manager.hpp"
 
 #include "base/logging.hpp"
diff --git a/drape/glstate.cpp b/drape/render_state.cpp
index 6f52e0bfc8..90e4cd987b 100644
--- a/drape/glstate.cpp
+++ b/drape/render_state.cpp
@@ -1,4 +1,4 @@
-#include "drape/glstate.hpp"
+#include "drape/render_state.hpp"
 #include "drape/glfunctions.hpp"
 
 #include "base/buffer_vector.hpp"
@@ -33,60 +33,60 @@ bool Blending::operator<(Blending const & other) const { return m_isEnabled < ot
 
 bool Blending::operator==(Blending const & other) const { return m_isEnabled == other.m_isEnabled; }
 
-glConst GLState::GetDepthFunction() const
+glConst RenderState::GetDepthFunction() const
 {
   return m_depthFunction;
 }
 
-void GLState::SetDepthFunction(glConst functionName)
+void RenderState::SetDepthFunction(glConst functionName)
 {
   m_depthFunction = functionName;
 }
 
-bool GLState::GetDepthTestEnabled() const
+bool RenderState::GetDepthTestEnabled() const
 {
   return m_depthTestEnabled;
 }
 
-void GLState::SetDepthTestEnabled(bool enabled)
+void RenderState::SetDepthTestEnabled(bool enabled)
 {
   m_depthTestEnabled = enabled;
 }
 
-glConst GLState::GetTextureFilter() const
+glConst RenderState::GetTextureFilter() const
 {
   return m_textureFilter;
 }
 
-void GLState::SetTextureFilter(glConst filter)
+void RenderState::SetTextureFilter(glConst filter)
 {
   m_textureFilter = filter;
 }
 
-bool GLState::GetDrawAsLine() const
+bool RenderState::GetDrawAsLine() const
 {
   return m_drawAsLine;
 }
 
-void GLState::SetDrawAsLine(bool drawAsLine)
+void RenderState::SetDrawAsLine(bool drawAsLine)
 {
   m_drawAsLine = drawAsLine;
 }
 
-int GLState::GetLineWidth() const
+int RenderState::GetLineWidth() const
 {
   return m_lineWidth;
 }
 
-void GLState::SetLineWidth(int width)
+void RenderState::SetLineWidth(int width)
 {
   m_lineWidth = width;
 }
 
-bool GLState::operator<(GLState const & other) const
+bool RenderState::operator<(RenderState const & other) const
 {
-  if (!m_renderState->Equal(other.m_renderState))
-    return m_renderState->Less(other.m_renderState);
+  if (!m_renderStateExtension->Equal(other.m_renderStateExtension))
+    return m_renderStateExtension->Less(other.m_renderStateExtension);
   if (!(m_blending == other.m_blending))
     return m_blending < other.m_blending;
   if (m_gpuProgram != other.m_gpuProgram)
@@ -107,9 +107,9 @@ bool GLState::operator<(GLState const & other) const
   return m_lineWidth < other.m_lineWidth;
 }
 
-bool GLState::operator==(GLState const & other) const
+bool RenderState::operator==(RenderState const & other) const
 {
-  return m_renderState->Equal(other.m_renderState) &&
+  return m_renderStateExtension->Equal(other.m_renderStateExtension) &&
          m_gpuProgram == other.m_gpuProgram &&
          m_gpuProgram3d == other.m_gpuProgram3d &&
          m_blending == other.m_blending &&
@@ -121,14 +121,14 @@ bool GLState::operator==(GLState const & other) const
          m_lineWidth == other.m_lineWidth;
 }
 
-bool GLState::operator!=(GLState const & other) const
+bool RenderState::operator!=(RenderState const & other) const
 {
   return !operator==(other);
 }
 
 uint8_t TextureState::m_usedSlots = 0;
 
-void TextureState::ApplyTextures(GLState const & state, ref_ptr<GpuProgram> program)
+void TextureState::ApplyTextures(RenderState const & state, ref_ptr<GpuProgram> program)
 {
   m_usedSlots = 0;
 
@@ -160,12 +160,12 @@ uint8_t TextureState::GetLastUsedSlots()
   return m_usedSlots;
 }
 
-void ApplyBlending(GLState const & state)
+void ApplyBlending(RenderState const & state)
 {
   state.GetBlending().Apply();
 }
 
-void ApplyState(GLState const & state, ref_ptr<GpuProgram> program)
+void ApplyState(RenderState const & state, ref_ptr<GpuProgram> program)
 {
   TextureState::ApplyTextures(state, program);
   ApplyBlending(state);
diff --git a/drape/glstate.hpp b/drape/render_state.hpp
index 9c3ca73b6a..333e4f696d 100644
--- a/drape/glstate.hpp
+++ b/drape/render_state.hpp
@@ -34,31 +34,31 @@ struct Blending
   bool m_isEnabled;
 };
 
-class BaseRenderState
+class BaseRenderStateExtension
 {
 public:
-  virtual ~BaseRenderState() = default;
-  virtual bool Less(ref_ptr<dp::BaseRenderState> other) const = 0;
-  virtual bool Equal(ref_ptr<dp::BaseRenderState> other) const = 0;
+  virtual ~BaseRenderStateExtension() = default;
+  virtual bool Less(ref_ptr<dp::BaseRenderStateExtension> other) const = 0;
+  virtual bool Equal(ref_ptr<dp::BaseRenderStateExtension> other) const = 0;
 };
 
-class GLState
+class RenderState
 {
 public:
   template<typename ProgramType>
-  GLState(ProgramType gpuProgram, ref_ptr<BaseRenderState> renderState)
-    : m_renderState(std::move(renderState))
+  RenderState(ProgramType gpuProgram, ref_ptr<BaseRenderStateExtension> renderStateExtension)
+    : m_renderStateExtension(std::move(renderStateExtension))
     , m_gpuProgram(static_cast<size_t>(gpuProgram))
     , m_gpuProgram3d(static_cast<size_t>(gpuProgram))
   {
-    ASSERT(m_renderState != nullptr, ());
+    ASSERT(m_renderStateExtension != nullptr, ());
   }
 
-  template<typename RenderStateType>
-  ref_ptr<RenderStateType> GetRenderState() const
+  template<typename RenderStateExtensionType>
+  ref_ptr<RenderStateExtensionType> GetRenderStateExtension() const
   {
-    ASSERT(dynamic_cast<RenderStateType *>(m_renderState.get()) != nullptr, ());
-    return make_ref(static_cast<RenderStateType *>(m_renderState.get()));
+    ASSERT(dynamic_cast<RenderStateExtensionType *>(m_renderStateExtension.get()) != nullptr, ());
+    return make_ref(static_cast<RenderStateExtensionType *>(m_renderStateExtension.get()));
   }
 
   void SetColorTexture(ref_ptr<Texture> tex) { m_colorTexture = tex; }
@@ -93,12 +93,12 @@ public:
   int GetLineWidth() const;
   void SetLineWidth(int width);
 
-  bool operator<(GLState const & other) const;
-  bool operator==(GLState const & other) const;
-  bool operator!=(GLState const & other) const;
+  bool operator<(RenderState const & other) const;
+  bool operator==(RenderState const & other) const;
+  bool operator!=(RenderState const & other) const;
 
 private:
-  ref_ptr<BaseRenderState> m_renderState;
+  ref_ptr<BaseRenderStateExtension> m_renderStateExtension;
   size_t m_gpuProgram;
   size_t m_gpuProgram3d;
   Blending m_blending;
@@ -118,13 +118,13 @@ private:
 class TextureState
 {
 public:
-  static void ApplyTextures(GLState const & state, ref_ptr<GpuProgram> program);
+  static void ApplyTextures(RenderState const & state, ref_ptr<GpuProgram> program);
   static uint8_t GetLastUsedSlots();
 
 private:
   static uint8_t m_usedSlots;
 };
 
-void ApplyState(GLState const & state, ref_ptr<GpuProgram> program);
-void ApplyBlending(GLState const & state);
+void ApplyState(RenderState const & state, ref_ptr<GpuProgram> program);
+void ApplyBlending(RenderState const & state);
 }  // namespace dp
diff --git a/drape_frontend/CMakeLists.txt b/drape_frontend/CMakeLists.txt
index 918b4c8e84..8340050538 100644
--- a/drape_frontend/CMakeLists.txt
+++ b/drape_frontend/CMakeLists.txt
@@ -154,8 +154,8 @@ set(
   render_group.cpp
   render_group.hpp
   render_node.hpp
-  render_state.cpp
-  render_state.hpp
+  render_state_extension.cpp
+  render_state_extension.hpp
   requested_tiles.cpp
   requested_tiles.hpp
   route_builder.cpp
diff --git a/drape_frontend/apply_feature_functors.cpp b/drape_frontend/apply_feature_functors.cpp
index c45f7aae2e..b49ace75b7 100644
--- a/drape_frontend/apply_feature_functors.cpp
+++ b/drape_frontend/apply_feature_functors.cpp
@@ -484,7 +484,7 @@ void BaseApplyFeature::SetHotelData(HotelData && hotelData)
 ApplyPointFeature::ApplyPointFeature(TileKey const & tileKey, TInsertShapeFn const & insertShape,
                                      FeatureID const & id, int minVisibleScale, uint8_t rank,
                                      CaptionDescription const & captions, float posZ,
-                                     int displacementMode, RenderState::DepthLayer depthLayer)
+                                     int displacementMode, DepthLayer depthLayer)
   : TBase(tileKey, insertShape, id, minVisibleScale, rank, captions)
   , m_posZ(posZ)
   , m_hasPoint(false)
@@ -532,8 +532,8 @@ void ApplyPointFeature::ProcessPointRule(Stylist::TRuleWrapper const & rule)
     params.m_tileCenter = m_tileRect.Center();
     ExtractCaptionParams(capRule, pRule->GetCaption(1), depth, params);
     params.m_depthLayer = m_depthLayer;
-    params.m_depthTestEnabled = m_depthLayer != RenderState::NavigationLayer &&
-      m_depthLayer != RenderState::OverlayLayer;
+    params.m_depthTestEnabled = m_depthLayer != DepthLayer::NavigationLayer &&
+      m_depthLayer != DepthLayer::OverlayLayer;
     params.m_minVisibleScale = m_minVisibleScale;
     params.m_rank = m_rank;
     params.m_posZ = m_posZ;
@@ -568,7 +568,7 @@ void ApplyPointFeature::Finish(ref_ptr<dp::TextureManager> texMng)
     specialDisplacementMode = true;
     specialModePriority = CalculateHotelOverlayPriority(m_hotelData);
   }
-  else if (m_depthLayer == RenderState::NavigationLayer && GetStyleReader().IsCarNavigationStyle())
+  else if (m_depthLayer == DepthLayer::NavigationLayer && GetStyleReader().IsCarNavigationStyle())
   {
     specialDisplacementMode = true;
     specialModePriority = CalculateNavigationPoiPriority();
@@ -580,8 +580,8 @@ void ApplyPointFeature::Finish(ref_ptr<dp::TextureManager> texMng)
   {
     PoiSymbolViewParams params(m_id);
     params.m_tileCenter = m_tileRect.Center();
-    params.m_depthTestEnabled = m_depthLayer != RenderState::NavigationLayer &&
-      m_depthLayer != RenderState::OverlayLayer;
+    params.m_depthTestEnabled = m_depthLayer != DepthLayer::NavigationLayer &&
+      m_depthLayer != DepthLayer::OverlayLayer;
     params.m_depth = static_cast<float>(m_symbolDepth);
     params.m_depthLayer = m_depthLayer;
     params.m_minVisibleScale = m_minVisibleScale;
@@ -651,7 +651,7 @@ ApplyAreaFeature::ApplyAreaFeature(TileKey const & tileKey, TInsertShapeFn const
                                    bool skipAreaGeometry, float minPosZ, float posZ, int minVisibleScale,
                                    uint8_t rank, CaptionDescription const & captions, bool hatchingArea)
   : TBase(tileKey, insertShape, id, minVisibleScale, rank, captions, posZ,
-          dp::displacement::kDefaultMode, RenderState::OverlayLayer)
+          dp::displacement::kDefaultMode, DepthLayer::OverlayLayer)
   , m_minPosZ(minPosZ)
   , m_isBuilding(isBuilding)
   , m_skipAreaGeometry(skipAreaGeometry)
@@ -1015,7 +1015,7 @@ void ApplyLineFeatureAdditional::GetRoadShieldsViewParams(ref_ptr<dp::TextureMan
   textParams.m_tileCenter = m_tileRect.Center();
   textParams.m_depthTestEnabled = false;
   textParams.m_depth = m_depth;
-  textParams.m_depthLayer = RenderState::OverlayLayer;
+  textParams.m_depthLayer = DepthLayer::OverlayLayer;
   textParams.m_minVisibleScale = kShieldMinVisibleZoomLevel;
   textParams.m_rank = m_rank;
   textParams.m_featureID = m_id;
@@ -1046,7 +1046,7 @@ void ApplyLineFeatureAdditional::GetRoadShieldsViewParams(ref_ptr<dp::TextureMan
     symbolParams.m_tileCenter = m_tileRect.Center();
     symbolParams.m_depthTestEnabled = true;
     symbolParams.m_depth = m_depth;
-    symbolParams.m_depthLayer = RenderState::OverlayLayer;
+    symbolParams.m_depthLayer = DepthLayer::OverlayLayer;
     symbolParams.m_minVisibleScale = kShieldMinVisibleZoomLevel;
     symbolParams.m_rank = m_rank;
     symbolParams.m_anchor = anchor;
@@ -1074,7 +1074,7 @@ void ApplyLineFeatureAdditional::GetRoadShieldsViewParams(ref_ptr<dp::TextureMan
     poiParams.m_tileCenter = m_tileRect.Center();
     poiParams.m_depth = m_depth;
     poiParams.m_depthTestEnabled = false;
-    poiParams.m_depthLayer = RenderState::OverlayLayer;
+    poiParams.m_depthLayer = DepthLayer::OverlayLayer;
     poiParams.m_minVisibleScale = kShieldMinVisibleZoomLevel;
     poiParams.m_rank = m_rank;
     poiParams.m_symbolName = symbolName;
diff --git a/drape_frontend/apply_feature_functors.hpp b/drape_frontend/apply_feature_functors.hpp
index f276a57f9a..01cc0f60a8 100644
--- a/drape_frontend/apply_feature_functors.hpp
+++ b/drape_frontend/apply_feature_functors.hpp
@@ -79,7 +79,7 @@ public:
   ApplyPointFeature(TileKey const & tileKey, TInsertShapeFn const & insertShape,
                     FeatureID const & id, int minVisibleScale, uint8_t rank,
                     CaptionDescription const & captions, float posZ,
-                    int displacementMode, RenderState::DepthLayer depthLayer);
+                    int displacementMode, DepthLayer depthLayer);
 
   void operator()(m2::PointD const & point, bool hasArea, bool isUGC);
   void ProcessPointRule(Stylist::TRuleWrapper const & rule);
@@ -94,7 +94,7 @@ private:
   bool m_createdByEditor;
   bool m_obsoleteInEditor;
   bool m_isUGC;
-  RenderState::DepthLayer m_depthLayer;
+  DepthLayer m_depthLayer;
   double m_symbolDepth;
   SymbolRuleProto const * m_symbolRule;
   m2::PointF m_centerPoint;
diff --git a/drape_frontend/area_shape.cpp b/drape_frontend/area_shape.cpp
index 334654900a..7eb82cf708 100644
--- a/drape_frontend/area_shape.cpp
+++ b/drape_frontend/area_shape.cpp
@@ -1,5 +1,5 @@
 #include "drape_frontend/area_shape.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 
 #include "shaders/programs.hpp"
 
@@ -60,7 +60,7 @@ void AreaShape::DrawArea(ref_ptr<dp::Batcher> batcher, m2::PointD const & colorU
                  m_params.m_depth), uv);
   });
 
-  auto state = CreateGLState(gpu::Program::Area, RenderState::GeometryLayer);
+  auto state = CreateRenderState(gpu::Program::Area, DepthLayer::GeometryLayer);
   state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
   state.SetColorTexture(texture);
 
@@ -82,7 +82,7 @@ void AreaShape::DrawArea(ref_ptr<dp::Batcher> batcher, m2::PointD const & colorU
       vertices.emplace_back(gpu::AreaVertex(glsl::vec3(pos, m_params.m_depth), ouv));
     }
 
-    auto outlineState = CreateGLState(gpu::Program::AreaOutline, RenderState::GeometryLayer);
+    auto outlineState = CreateRenderState(gpu::Program::AreaOutline, DepthLayer::GeometryLayer);
     outlineState.SetDepthTestEnabled(m_params.m_depthTestEnabled);
     outlineState.SetColorTexture(texture);
     outlineState.SetDrawAsLine(true);
@@ -116,7 +116,7 @@ void AreaShape::DrawHatchingArea(ref_ptr<dp::Batcher> batcher, m2::PointD const
     vertexes[i].m_maskTexCoord.y = static_cast<float>(maxV * (m_vertexes[i].y - bbox.minY()) / bbox.SizeY());
   }
 
-  auto state = CreateGLState(gpu::Program::HatchingArea, RenderState::GeometryLayer);
+  auto state = CreateRenderState(gpu::Program::HatchingArea, DepthLayer::GeometryLayer);
   state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
   state.SetColorTexture(texture);
   state.SetMaskTexture(hatchingTexture);
@@ -165,7 +165,7 @@ void AreaShape::DrawArea3D(ref_ptr<dp::Batcher> batcher, m2::PointD const & colo
     vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(pt, -m_params.m_posZ), normal, uv));
   }
 
-  auto state = CreateGLState(gpu::Program::Area3d, RenderState::Geometry3dLayer);
+  auto state = CreateRenderState(gpu::Program::Area3d, DepthLayer::Geometry3dLayer);
   state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
   state.SetColorTexture(texture);
   state.SetBlending(dp::Blending(false /* isEnabled */));
@@ -179,7 +179,7 @@ void AreaShape::DrawArea3D(ref_ptr<dp::Batcher> batcher, m2::PointD const & colo
   {
     glsl::vec2 const ouv = glsl::ToVec2(outlineUv);
 
-    auto outlineState = CreateGLState(gpu::Program::Area3dOutline, RenderState::Geometry3dLayer);
+    auto outlineState = CreateRenderState(gpu::Program::Area3dOutline, DepthLayer::Geometry3dLayer);
     outlineState.SetDepthTestEnabled(m_params.m_depthTestEnabled);
     outlineState.SetColorTexture(texture);
     outlineState.SetBlending(dp::Blending(false /* isEnabled */));
diff --git a/drape_frontend/arrow3d.cpp b/drape_frontend/arrow3d.cpp
index 05d1efafb5..b725ef6427 100644
--- a/drape_frontend/arrow3d.cpp
+++ b/drape_frontend/arrow3d.cpp
@@ -34,7 +34,7 @@ df::ColorConstant const kArrow3DColor = "Arrow3D";
 df::ColorConstant const kArrow3DOutlineColor = "Arrow3DOutline";
 
 Arrow3d::Arrow3d()
-  : m_state(CreateGLState(gpu::Program::Arrow3d, RenderState::OverlayLayer))
+  : m_state(CreateRenderState(gpu::Program::Arrow3d, DepthLayer::OverlayLayer))
 {
   m_state.SetDepthTestEnabled(false);
   m_vertices = {
diff --git a/drape_frontend/arrow3d.hpp b/drape_frontend/arrow3d.hpp
index 9cdb32e931..28946f2a47 100644
--- a/drape_frontend/arrow3d.hpp
+++ b/drape_frontend/arrow3d.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 
 #include "drape/pointers.hpp"
 
@@ -56,7 +56,7 @@ private:
   std::vector<float> m_vertices;
   std::vector<float> m_normals;
 
-  dp::GLState m_state;
+  dp::RenderState m_state;
 
   bool m_isInitialized = false;
 };
diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp
index 5dbfec942a..19dc3a124d 100644
--- a/drape_frontend/backend_renderer.cpp
+++ b/drape_frontend/backend_renderer.cpp
@@ -678,7 +678,7 @@ void BackendRenderer::RecacheMapShapes()
   m_commutator->PostMessage(ThreadsCommutator::RenderThread, std::move(msg), MessagePriority::Normal);
 }
 
-void BackendRenderer::FlushGeometry(TileKey const & key, dp::GLState const & state,
+void BackendRenderer::FlushGeometry(TileKey const & key, dp::RenderState const & state,
                                     drape_ptr<dp::RenderBucket> && buffer)
 {
   m_contextFactory->GetResourcesUploadContext()->Flush();
diff --git a/drape_frontend/backend_renderer.hpp b/drape_frontend/backend_renderer.hpp
index f6c30cee2c..479d190b09 100644
--- a/drape_frontend/backend_renderer.hpp
+++ b/drape_frontend/backend_renderer.hpp
@@ -98,7 +98,7 @@ private:
   void ReleaseResources();
 
   void InitGLDependentResource();
-  void FlushGeometry(TileKey const & key, dp::GLState const & state, drape_ptr<dp::RenderBucket> && buffer);
+  void FlushGeometry(TileKey const & key, dp::RenderState const & state, drape_ptr<dp::RenderBucket> && buffer);
 
   void FlushTransitRenderData(TransitRenderData && renderData);
   void FlushTrafficRenderData(TrafficRenderData && renderData);
diff --git a/drape_frontend/batchers_pool.hpp b/drape_frontend/batchers_pool.hpp
index 654d65b960..710b172b29 100644
--- a/drape_frontend/batchers_pool.hpp
+++ b/drape_frontend/batchers_pool.hpp
@@ -15,7 +15,7 @@ template <typename TKey, typename TKeyComparator>
 class BatchersPool final
 {
 public:
-  using TFlushFn = std::function<void (TKey const & key, dp::GLState const & state,
+  using TFlushFn = std::function<void (TKey const & key, dp::RenderState const & state,
                                        drape_ptr<dp::RenderBucket> && buffer)>;
 
   BatchersPool(int initBatchersCount, TFlushFn const & flushFn,
diff --git a/drape_frontend/circles_pack_shape.cpp b/drape_frontend/circles_pack_shape.cpp
index 942f19a105..553b109715 100644
--- a/drape_frontend/circles_pack_shape.cpp
+++ b/drape_frontend/circles_pack_shape.cpp
@@ -25,9 +25,9 @@ struct CirclesPackStaticVertex
   TNormal m_normal;
 };
 
-dp::GLState GetCirclesPackState(ref_ptr<dp::TextureManager> texMng)
+dp::RenderState GetCirclesPackState(ref_ptr<dp::TextureManager> texMng)
 {
-  auto state = CreateGLState(gpu::Program::CirclePoint, RenderState::OverlayLayer);
+  auto state = CreateRenderState(gpu::Program::CirclePoint, DepthLayer::OverlayLayer);
   state.SetColorTexture(texMng->GetSymbolsTexture());
   state.SetDepthTestEnabled(false);
   return state;
@@ -157,7 +157,7 @@ void CirclesPackShape::Draw(ref_ptr<dp::TextureManager> texMng, ref_ptr<dp::Grap
   dynamicVertexData.resize(data.m_pointsCount * kVerticesInPoint);
 
   dp::Batcher batcher(data.m_pointsCount * kIndicesInPoint, data.m_pointsCount * kVerticesInPoint);
-  dp::SessionGuard guard(batcher, [&data](dp::GLState const & state, drape_ptr<dp::RenderBucket> && b)
+  dp::SessionGuard guard(batcher, [&data](dp::RenderState const & state, drape_ptr<dp::RenderBucket> && b)
   {
     data.m_bucket = std::move(b);
     data.m_state = state;
diff --git a/drape_frontend/circles_pack_shape.hpp b/drape_frontend/circles_pack_shape.hpp
index 52f916b42f..065b7374e0 100644
--- a/drape_frontend/circles_pack_shape.hpp
+++ b/drape_frontend/circles_pack_shape.hpp
@@ -2,7 +2,7 @@
 
 #include "drape_frontend/map_shape.hpp"
 #include "drape_frontend/shape_view_params.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 
 #include "drape/overlay_handle.hpp"
 #include "drape/pointers.hpp"
@@ -23,11 +23,11 @@ struct CirclesPackRenderData
 {
   uint32_t m_pointsCount;
 
-  dp::GLState m_state;
+  dp::RenderState m_state;
   drape_ptr<dp::RenderBucket> m_bucket;
   CirclesPackRenderData()
     : m_pointsCount(0)
-    , m_state(CreateGLState(gpu::Program::CirclePoint, RenderState::OverlayLayer))
+    , m_state(CreateRenderState(gpu::Program::CirclePoint, DepthLayer::OverlayLayer))
   {}
 };
 
diff --git a/drape_frontend/colored_symbol_shape.cpp b/drape_frontend/colored_symbol_shape.cpp
index 11a45bf21c..ae4f50ad8f 100644
--- a/drape_frontend/colored_symbol_shape.cpp
+++ b/drape_frontend/colored_symbol_shape.cpp
@@ -1,6 +1,6 @@
 #include "drape_frontend/colored_symbol_shape.hpp"
 
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/visual_params.hpp"
 
 #include "shaders/programs.hpp"
@@ -298,7 +298,7 @@ void ColoredSymbolShape::Draw(ref_ptr<dp::Batcher> batcher,
     }
     handle->SetOverlayRank(m_params.m_startOverlayRank);
   }
-  auto state = CreateGLState(gpu::Program::ColoredSymbol, m_params.m_depthLayer);
+  auto state = CreateRenderState(gpu::Program::ColoredSymbol, m_params.m_depthLayer);
   state.SetProgram3d(gpu::Program::ColoredSymbolBillboard);
   state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
   state.SetColorTexture(colorRegion.GetTexture());
diff --git a/drape_frontend/drape_api_builder.cpp b/drape_frontend/drape_api_builder.cpp
index 1b2222fd2f..4423ca1f89 100644
--- a/drape_frontend/drape_api_builder.cpp
+++ b/drape_frontend/drape_api_builder.cpp
@@ -55,7 +55,7 @@ void DrapeApiBuilder::BuildLines(DrapeApi::TLines const & lines, ref_ptr<dp::Tex
     auto property = make_unique_dp<DrapeApiRenderProperty>();
     property->m_center = rect.Center();
     {
-      dp::SessionGuard guard(batcher, [&property, id](dp::GLState const & state, drape_ptr<dp::RenderBucket> && b)
+      dp::SessionGuard guard(batcher, [&property, id](dp::RenderState const & state, drape_ptr<dp::RenderBucket> && b)
       {
         property->m_id = id;
         property->m_buckets.push_back(make_pair(state, move(b)));
diff --git a/drape_frontend/drape_api_builder.hpp b/drape_frontend/drape_api_builder.hpp
index 891862afab..6caa12b476 100644
--- a/drape_frontend/drape_api_builder.hpp
+++ b/drape_frontend/drape_api_builder.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "drape_frontend/drape_api.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 
 #include "drape/render_bucket.hpp"
 #include "drape/texture_manager.hpp"
@@ -17,7 +17,7 @@ struct DrapeApiRenderProperty
 {
   string m_id;
   m2::PointD m_center;
-  vector<pair<dp::GLState, drape_ptr<dp::RenderBucket>>> m_buckets;
+  vector<pair<dp::RenderState, drape_ptr<dp::RenderBucket>>> m_buckets;
 };
 
 class DrapeApiBuilder
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index 16cdd58bcd..c187a19272 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -216,7 +216,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
   case Message::FlushTile:
     {
       ref_ptr<FlushRenderBucketMessage> msg = message;
-      dp::GLState const & state = msg->GetState();
+      dp::RenderState const & state = msg->GetState();
       TileKey const & key = msg->GetKey();
       drape_ptr<dp::RenderBucket> bucket = msg->AcceptBuffer();
       if (key.m_zoomLevel == m_currentZoomLevel && CheckTileGenerations(key))
@@ -1031,11 +1031,11 @@ void FrontendRenderer::OnResize(ScreenBase const & screen)
 }
 
 template<typename TRenderGroup>
-void FrontendRenderer::AddToRenderGroup(dp::GLState const & state,
+void FrontendRenderer::AddToRenderGroup(dp::RenderState const & state,
                                         drape_ptr<dp::RenderBucket> && renderBucket,
                                         TileKey const & newTile)
 {
-  RenderLayer & layer = m_layers[GetDepthLayer(state)];
+  RenderLayer & layer = m_layers[static_cast<size_t>(GetDepthLayer(state))];
   for (auto const & g : layer.m_renderGroups)
   {
     if (!g->IsPendingOnDelete() && g->GetState() == state && g->GetTileKey().EqualStrict(newTile))
@@ -1214,7 +1214,7 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView, bool activeFram
     context->Clear(dp::ClearBits::ColorBit | dp::ClearBits::DepthBit | dp::ClearBits::StencilBit);
 
     Render2dLayer(modelView);
-    RenderUserMarksLayer(modelView, RenderState::UserLineLayer);
+    RenderUserMarksLayer(modelView, DepthLayer::UserLineLayer);
 
     if (m_buildingsFramebuffer->IsSupported())
     {
@@ -1253,7 +1253,7 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView, bool activeFram
     {
       StencilWriterGuard guard(make_ref(m_postprocessRenderer));
       RenderOverlayLayer(modelView);
-      RenderUserMarksLayer(modelView, RenderState::LocalAdsMarkLayer);
+      RenderUserMarksLayer(modelView, DepthLayer::LocalAdsMarkLayer);
     }
 
     m_gpsTrackRenderer->RenderTrack(modelView, m_currentZoomLevel, make_ref(m_gpuProgramManager),
@@ -1271,9 +1271,9 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView, bool activeFram
 
     {
       StencilWriterGuard guard(make_ref(m_postprocessRenderer));
-      RenderUserMarksLayer(modelView, RenderState::UserMarkLayer);
-      RenderUserMarksLayer(modelView, RenderState::TransitMarkLayer);
-      RenderUserMarksLayer(modelView, RenderState::RoutingMarkLayer);
+      RenderUserMarksLayer(modelView, DepthLayer::UserMarkLayer);
+      RenderUserMarksLayer(modelView, DepthLayer::TransitMarkLayer);
+      RenderUserMarksLayer(modelView, DepthLayer::RoutingMarkLayer);
       RenderSearchMarksLayer(modelView);
     }
 
@@ -1305,7 +1305,7 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView, bool activeFram
 
 void FrontendRenderer::Render2dLayer(ScreenBase const & modelView)
 {
-  RenderLayer & layer2d = m_layers[RenderState::GeometryLayer];
+  RenderLayer & layer2d = m_layers[static_cast<size_t>(DepthLayer::GeometryLayer)];
   layer2d.Sort(make_ref(m_overlayTree));
 
   for (drape_ptr<RenderGroup> const & group : layer2d.m_renderGroups)
@@ -1314,7 +1314,7 @@ void FrontendRenderer::Render2dLayer(ScreenBase const & modelView)
 
 void FrontendRenderer::Render3dLayer(ScreenBase const & modelView, bool useFramebuffer)
 {
-  RenderLayer & layer = m_layers[RenderState::Geometry3dLayer];
+  RenderLayer & layer = m_layers[static_cast<size_t>(DepthLayer::Geometry3dLayer)];
   if (layer.m_renderGroups.empty())
     return;
 
@@ -1347,7 +1347,7 @@ void FrontendRenderer::Render3dLayer(ScreenBase const & modelView, bool useFrame
 
 void FrontendRenderer::RenderOverlayLayer(ScreenBase const & modelView)
 {
-  RenderLayer & overlay = m_layers[RenderState::OverlayLayer];
+  RenderLayer & overlay = m_layers[static_cast<size_t>(DepthLayer::OverlayLayer)];
   BuildOverlayTree(modelView);
   for (drape_ptr<RenderGroup> & group : overlay.m_renderGroups)
     RenderSingleGroup(modelView, make_ref(group));
@@ -1358,7 +1358,7 @@ void FrontendRenderer::RenderOverlayLayer(ScreenBase const & modelView)
 
 void FrontendRenderer::RenderNavigationOverlayLayer(ScreenBase const & modelView)
 {
-  RenderLayer & navOverlayLayer = m_layers[RenderState::NavigationLayer];
+  RenderLayer & navOverlayLayer = m_layers[static_cast<size_t>(DepthLayer::NavigationLayer)];
   for (auto & group : navOverlayLayer.m_renderGroups)
   {
     if (group->HasOverlayHandles())
@@ -1428,9 +1428,9 @@ void FrontendRenderer::RenderRouteLayer(ScreenBase const & modelView)
                                make_ref(m_gpuProgramManager), m_frameValues);
 }
 
-void FrontendRenderer::RenderUserMarksLayer(ScreenBase const & modelView, RenderState::DepthLayer layerId)
+void FrontendRenderer::RenderUserMarksLayer(ScreenBase const & modelView, DepthLayer layerId)
 {
-  auto & renderGroups = m_layers[layerId].m_renderGroups;
+  auto & renderGroups = m_layers[static_cast<size_t>(layerId)].m_renderGroups;
   if (renderGroups.empty())
     return;
 
@@ -1442,14 +1442,14 @@ void FrontendRenderer::RenderUserMarksLayer(ScreenBase const & modelView, Render
 
 void FrontendRenderer::RenderSearchMarksLayer(ScreenBase const & modelView)
 {
-  auto & layer = m_layers[RenderState::SearchMarkLayer];
+  auto & layer = m_layers[static_cast<size_t>(DepthLayer::SearchMarkLayer)];
   layer.Sort(nullptr);
   for (drape_ptr<RenderGroup> & group : layer.m_renderGroups)
   {
     group->SetOverlayVisibility(true);
     group->Update(modelView);
   }
-  RenderUserMarksLayer(modelView, RenderState::SearchMarkLayer);
+  RenderUserMarksLayer(modelView, DepthLayer::SearchMarkLayer);
 }
 
 void FrontendRenderer::RenderEmptyFrame()
@@ -1470,15 +1470,15 @@ void FrontendRenderer::RenderEmptyFrame()
 
 void FrontendRenderer::BuildOverlayTree(ScreenBase const & modelView)
 {
-  static std::vector<RenderState::DepthLayer> layers = {RenderState::OverlayLayer,
-                                                        RenderState::LocalAdsMarkLayer,
-                                                        RenderState::NavigationLayer,
-                                                        RenderState::TransitMarkLayer,
-                                                        RenderState::RoutingMarkLayer};
+  static std::vector<DepthLayer> layers = {DepthLayer::OverlayLayer,
+                                           DepthLayer::LocalAdsMarkLayer,
+                                           DepthLayer::NavigationLayer,
+                                           DepthLayer::TransitMarkLayer,
+                                           DepthLayer::RoutingMarkLayer};
   BeginUpdateOverlayTree(modelView);
   for (auto const & layerId : layers)
   {
-    RenderLayer & overlay = m_layers[layerId];
+    RenderLayer & overlay = m_layers[static_cast<size_t>(layerId)];
     overlay.Sort(make_ref(m_overlayTree));
     for (drape_ptr<RenderGroup> & group : overlay.m_renderGroups)
       UpdateOverlayTree(modelView, group);
@@ -1488,7 +1488,7 @@ void FrontendRenderer::BuildOverlayTree(ScreenBase const & modelView)
   EndUpdateOverlayTree();
 }
 
-void FrontendRenderer::PrepareBucket(dp::GLState const & state, drape_ptr<dp::RenderBucket> & bucket)
+void FrontendRenderer::PrepareBucket(dp::RenderState const & state, drape_ptr<dp::RenderBucket> & bucket)
 {
   auto program = m_gpuProgramManager->GetProgram(state.GetProgram<gpu::Program>());
   auto program3d = m_gpuProgramManager->GetProgram(state.GetProgram3d<gpu::Program>());
diff --git a/drape_frontend/frontend_renderer.hpp b/drape_frontend/frontend_renderer.hpp
index 982e0d1237..e84866d2d9 100755
--- a/drape_frontend/frontend_renderer.hpp
+++ b/drape_frontend/frontend_renderer.hpp
@@ -13,7 +13,7 @@
 #include "drape_frontend/navigator.hpp"
 #include "drape_frontend/overlays_tracker.hpp"
 #include "drape_frontend/render_group.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/requested_tiles.hpp"
 #include "drape_frontend/route_renderer.hpp"
 #include "drape_frontend/postprocess_renderer.hpp"
@@ -143,7 +143,7 @@ protected:
 private:
   void OnResize(ScreenBase const & screen);
   void RenderScene(ScreenBase const & modelView, bool activeFrame);
-  void PrepareBucket(dp::GLState const & state, drape_ptr<dp::RenderBucket> & bucket);
+  void PrepareBucket(dp::RenderState const & state, drape_ptr<dp::RenderBucket> & bucket);
   void RenderSingleGroup(ScreenBase const & modelView, ref_ptr<BaseRenderGroup> group);
   void RefreshProjection(ScreenBase const & screen);
   void RefreshZScale(ScreenBase const & screen);
@@ -162,7 +162,7 @@ private:
   void Render3dLayer(ScreenBase const & modelView, bool useFramebuffer);
   void RenderOverlayLayer(ScreenBase const & modelView);
   void RenderNavigationOverlayLayer(ScreenBase const & modelView);
-  void RenderUserMarksLayer(ScreenBase const & modelView, RenderState::DepthLayer layerId);
+  void RenderUserMarksLayer(ScreenBase const & modelView, DepthLayer layerId);
   void RenderTransitSchemeLayer(ScreenBase const & modelView);
   void RenderTrafficLayer(ScreenBase const & modelView);
   void RenderRouteLayer(ScreenBase const & modelView);
@@ -224,7 +224,7 @@ private:
   void EndUpdateOverlayTree();
 
   template<typename TRenderGroup>
-  void AddToRenderGroup(dp::GLState const & state, drape_ptr<dp::RenderBucket> && renderBucket,
+  void AddToRenderGroup(dp::RenderState const & state, drape_ptr<dp::RenderBucket> && renderBucket,
                         TileKey const & newTile);
 
   using TRenderGroupRemovePredicate = std::function<bool(drape_ptr<RenderGroup> const &)>;
@@ -256,7 +256,7 @@ private:
 
   drape_ptr<gpu::ProgramManager> m_gpuProgramManager;
 
-  std::array<RenderLayer, RenderState::LayersCount> m_layers;
+  std::array<RenderLayer, static_cast<size_t>(DepthLayer::LayersCount)> m_layers;
 
   drape_ptr<gui::LayerRenderer> m_guiRenderer;
   gui::TWidgetsLayoutInfo m_lastWidgetsLayout;
@@ -296,7 +296,6 @@ private:
   ref_ptr<RequestedTiles> m_requestedTiles;
   uint64_t m_maxGeneration;
   uint64_t m_maxUserMarksGeneration;
-  int m_mergeBucketsCounter = 0;
 
   int m_lastRecacheRouteId = 0;
 
diff --git a/drape_frontend/gps_track_renderer.cpp b/drape_frontend/gps_track_renderer.cpp
index 36eba340db..a27cd8c412 100644
--- a/drape_frontend/gps_track_renderer.cpp
+++ b/drape_frontend/gps_track_renderer.cpp
@@ -309,7 +309,7 @@ void GpsTrackRenderer::RenderTrack(ScreenBase const & screen, int zoomLevel,
   program->Bind();
 
   ASSERT_GREATER(m_renderData.size(), 0, ());
-  dp::GLState const & state = m_renderData.front()->m_state;
+  dp::RenderState const & state = m_renderData.front()->m_state;
   dp::ApplyState(state, program);
   mng->GetParamsSetter()->Apply(program, params);
 
diff --git a/drape_frontend/gui/choose_position_mark.cpp b/drape_frontend/gui/choose_position_mark.cpp
index 7b813aa83e..394d462348 100644
--- a/drape_frontend/gui/choose_position_mark.cpp
+++ b/drape_frontend/gui/choose_position_mark.cpp
@@ -59,7 +59,7 @@ drape_ptr<ShapeRenderer> ChoosePositionMark::Draw(ref_ptr<dp::TextureManager> te
     ChoosePositionMarkVertex(glsl::vec2(halfSize.x, -halfSize.y), glsl::ToVec2(texRect.RightBottom()))
   };
 
-  auto state = df::CreateGLState(gpu::Program::TexturingGui, df::RenderState::GuiLayer);
+  auto state = df::CreateRenderState(gpu::Program::TexturingGui, df::DepthLayer::GuiLayer);
   state.SetColorTexture(region.GetTexture());
   state.SetDepthTestEnabled(false);
 
diff --git a/drape_frontend/gui/compass.cpp b/drape_frontend/gui/compass.cpp
index 814603ebe9..92c9fdca7f 100644
--- a/drape_frontend/gui/compass.cpp
+++ b/drape_frontend/gui/compass.cpp
@@ -106,7 +106,7 @@ drape_ptr<ShapeRenderer> Compass::Draw(m2::PointF & compassSize, ref_ptr<dp::Tex
     CompassVertex(glsl::vec2(halfSize.x, -halfSize.y), glsl::ToVec2(texRect.RightBottom()))
   };
 
-  auto state = df::CreateGLState(gpu::Program::TexturingGui, df::RenderState::GuiLayer);
+  auto state = df::CreateRenderState(gpu::Program::TexturingGui, df::DepthLayer::GuiLayer);
   state.SetColorTexture(region.GetTexture());
   state.SetDepthTestEnabled(false);
 
diff --git a/drape_frontend/gui/gui_text.cpp b/drape_frontend/gui/gui_text.cpp
index ccdd7d9eb9..8f7b4c77e1 100644
--- a/drape_frontend/gui/gui_text.cpp
+++ b/drape_frontend/gui/gui_text.cpp
@@ -106,7 +106,7 @@ dp::BindingInfo const & StaticLabel::Vertex::GetBindingInfo()
 }
 
 StaticLabel::LabelResult::LabelResult()
-  : m_state(df::CreateGLState(gpu::Program::TextOutlinedGui, df::RenderState::GuiLayer))
+  : m_state(df::CreateRenderState(gpu::Program::TextOutlinedGui, df::DepthLayer::GuiLayer))
 {
   m_state.SetDepthTestEnabled(false);
 }
@@ -287,7 +287,7 @@ dp::BindingInfo const & MutableLabel::DynamicVertex::GetBindingInfo()
 }
 
 MutableLabel::PrecacheResult::PrecacheResult()
-  : m_state(df::CreateGLState(gpu::Program::TextOutlinedGui, df::RenderState::GuiLayer))
+  : m_state(df::CreateRenderState(gpu::Program::TextOutlinedGui, df::DepthLayer::GuiLayer))
 {
   m_state.SetDepthTestEnabled(false);
 }
diff --git a/drape_frontend/gui/gui_text.hpp b/drape_frontend/gui/gui_text.hpp
index ed623d5355..67340d4b57 100644
--- a/drape_frontend/gui/gui_text.hpp
+++ b/drape_frontend/gui/gui_text.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "drape_frontend/gui/shape.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 
 #include "drape/binding_info.hpp"
 #include "drape/drape_global.hpp"
@@ -48,7 +48,7 @@ public:
   {
     LabelResult();
 
-    dp::GLState m_state;
+    dp::RenderState m_state;
     buffer_vector<Vertex, 128> m_buffer;
     m2::RectF m_boundRect;
     TAlphabet m_alphabet;
@@ -106,7 +106,7 @@ public:
   {
     PrecacheResult();
 
-    dp::GLState m_state;
+    dp::RenderState m_state;
     buffer_vector<StaticVertex, 128> m_buffer;
     m2::PointF m_maxPixelSize;
   };
diff --git a/drape_frontend/gui/ruler.cpp b/drape_frontend/gui/ruler.cpp
index 536bffb372..aaf37b1b21 100644
--- a/drape_frontend/gui/ruler.cpp
+++ b/drape_frontend/gui/ruler.cpp
@@ -213,7 +213,7 @@ void Ruler::DrawRuler(m2::PointF & size, ShapeControl & control, ref_ptr<dp::Tex
   data.push_back(RulerVertex(glsl::vec2(0.0, h), normals[1], texCoord));
   data.push_back(RulerVertex(glsl::vec2(0.0, -h), normals[1], texCoord));
 
-  auto state = df::CreateGLState(gpu::Program::Ruler, df::RenderState::GuiLayer);
+  auto state = df::CreateRenderState(gpu::Program::Ruler, df::DepthLayer::GuiLayer);
   state.SetColorTexture(reg.GetTexture());
   state.SetDepthTestEnabled(false);
 
diff --git a/drape_frontend/gui/shape.cpp b/drape_frontend/gui/shape.cpp
index c78b9d16b8..983b54ed98 100644
--- a/drape_frontend/gui/shape.cpp
+++ b/drape_frontend/gui/shape.cpp
@@ -123,7 +123,7 @@ void ShapeRenderer::Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManage
   });
 }
 
-void ShapeRenderer::AddShape(dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket)
+void ShapeRenderer::AddShape(dp::RenderState const & state, drape_ptr<dp::RenderBucket> && bucket)
 {
   m_shapes.emplace_back(ShapeControl());
   m_shapes.back().AddShape(state, std::move(bucket));
@@ -180,7 +180,7 @@ ref_ptr<Handle> ShapeRenderer::FindHandle(FeatureID const & id)
   return resultHandle;
 }
 
-ShapeControl::ShapeInfo::ShapeInfo(dp::GLState const & state,
+ShapeControl::ShapeInfo::ShapeInfo(dp::RenderState const & state,
                                    drape_ptr<dp::VertexArrayBuffer> && buffer,
                                    drape_ptr<Handle> && handle)
   : m_state(state)
@@ -194,7 +194,7 @@ void ShapeControl::ShapeInfo::Destroy()
   m_buffer.reset();
 }
 
-void ShapeControl::AddShape(dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket)
+void ShapeControl::AddShape(dp::RenderState const & state, drape_ptr<dp::RenderBucket> && bucket)
 {
   ASSERT(bucket->GetOverlayHandlesCount() == 1, ());
 
diff --git a/drape_frontend/gui/shape.hpp b/drape_frontend/gui/shape.hpp
index c687dc210b..228943a3e3 100644
--- a/drape_frontend/gui/shape.hpp
+++ b/drape_frontend/gui/shape.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "drape_frontend/gui/skin.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 
 #include "shaders/program_manager.hpp"
 
@@ -65,18 +65,18 @@ struct ShapeControl
 
   struct ShapeInfo
   {
-    ShapeInfo() : m_state(df::CreateGLState(gpu::Program::TexturingGui, df::RenderState::GuiLayer)) {}
-    ShapeInfo(dp::GLState const & state, drape_ptr<dp::VertexArrayBuffer> && buffer,
+    ShapeInfo() : m_state(df::CreateRenderState(gpu::Program::TexturingGui, df::DepthLayer::GuiLayer)) {}
+    ShapeInfo(dp::RenderState const & state, drape_ptr<dp::VertexArrayBuffer> && buffer,
               drape_ptr<Handle> && handle);
 
     void Destroy();
 
-    dp::GLState m_state;
+    dp::RenderState m_state;
     drape_ptr<dp::VertexArrayBuffer> m_buffer;
     drape_ptr<Handle> m_handle;
   };
 
-  void AddShape(dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket);
+  void AddShape(dp::RenderState const & state, drape_ptr<dp::RenderBucket> && bucket);
 
   std::vector<ShapeInfo> m_shapesInfo;
 };
@@ -90,7 +90,7 @@ public:
 
   void Build(ref_ptr<gpu::ProgramManager> mng);
   void Render(ScreenBase const & screen, ref_ptr<gpu::ProgramManager> mng);
-  void AddShape(dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket);
+  void AddShape(dp::RenderState const & state, drape_ptr<dp::RenderBucket> && bucket);
   void AddShapeControl(ShapeControl && control);
 
   void SetPivot(m2::PointF const & pivot);
diff --git a/drape_frontend/gui/watermark.cpp b/drape_frontend/gui/watermark.cpp
index 0d544ba7ec..bc7395ce4f 100644
--- a/drape_frontend/gui/watermark.cpp
+++ b/drape_frontend/gui/watermark.cpp
@@ -82,7 +82,7 @@ drape_ptr<ShapeRenderer> Watermark::Draw(m2::PointF & size, ref_ptr<dp::TextureM
     WatermarkVertex(glsl::vec2(halfSize.x, -halfSize.y), glsl::ToVec2(texRect.RightBottom()))
   };
 
-  auto state = df::CreateGLState(gpu::Program::TexturingGui, df::RenderState::GuiLayer);
+  auto state = df::CreateRenderState(gpu::Program::TexturingGui, df::DepthLayer::GuiLayer);
   state.SetColorTexture(region.GetTexture());
   state.SetDepthTestEnabled(false);
 
diff --git a/drape_frontend/line_shape.cpp b/drape_frontend/line_shape.cpp
index 6ddd32f949..8681706dbc 100644
--- a/drape_frontend/line_shape.cpp
+++ b/drape_frontend/line_shape.cpp
@@ -60,7 +60,7 @@ struct BaseBuilderParams
   float m_pxHalfWidth;
   float m_depth;
   bool m_depthTestEnabled;
-  RenderState::DepthLayer m_depthLayer;
+  DepthLayer m_depthLayer;
   dp::LineCap m_cap;
   dp::LineJoin m_join;
 };
@@ -112,7 +112,7 @@ public:
     return GetBindingInfo();
   }
 
-  dp::GLState GetCapState() override
+  dp::RenderState GetCapState() override
   {
     return GetState();
   }
@@ -175,9 +175,9 @@ public:
     : TBase(params, pointsInSpline * 2, (pointsInSpline - 2) * 8)
   {}
 
-  dp::GLState GetState() override
+  dp::RenderState GetState() override
   {
-    auto state = CreateGLState(gpu::Program::Line, m_params.m_depthLayer);
+    auto state = CreateRenderState(gpu::Program::Line, m_params.m_depthLayer);
     state.SetColorTexture(m_params.m_color.GetTexture());
     state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
     return state;
@@ -202,12 +202,12 @@ public:
     return *s_capInfo;
   }
 
-  dp::GLState GetCapState() override
+  dp::RenderState GetCapState() override
   {
     if (m_params.m_cap == dp::ButtCap)
       return TBase::GetCapState();
 
-    auto state = CreateGLState(gpu::Program::CapJoin, m_params.m_depthLayer);
+    auto state = CreateRenderState(gpu::Program::CapJoin, m_params.m_depthLayer);
     state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
     state.SetColorTexture(m_params.m_color.GetTexture());
     state.SetDepthFunction(gl_const::GLLess);
@@ -277,9 +277,9 @@ public:
     , m_lineWidth(lineWidth)
   {}
 
-  dp::GLState GetState() override
+  dp::RenderState GetState() override
   {
-    auto state = CreateGLState(gpu::Program::AreaOutline, m_params.m_depthLayer);
+    auto state = CreateRenderState(gpu::Program::AreaOutline, m_params.m_depthLayer);
     state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
     state.SetColorTexture(m_params.m_color.GetTexture());
     state.SetDrawAsLine(true);
@@ -321,9 +321,9 @@ public:
     return static_cast<int>((pixelLen + m_texCoordGen.GetMaskLength() - 1) / m_texCoordGen.GetMaskLength());
   }
 
-  dp::GLState GetState() override
+  dp::RenderState GetState() override
   {
-    auto state = CreateGLState(gpu::Program::DashedLine, m_params.m_depthLayer);
+    auto state = CreateRenderState(gpu::Program::DashedLine, m_params.m_depthLayer);
     state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
     state.SetColorTexture(m_params.m_color.GetTexture());
     state.SetMaskTexture(m_texCoordGen.GetRegion().GetTexture());
@@ -545,7 +545,7 @@ void LineShape::Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> t
     Prepare(textures);
 
   ASSERT(m_lineShapeInfo != nullptr, ());
-  dp::GLState state = m_lineShapeInfo->GetState();
+  dp::RenderState state = m_lineShapeInfo->GetState();
   dp::AttributeProvider provider(1, m_lineShapeInfo->GetLineSize());
   provider.InitStream(0, m_lineShapeInfo->GetBindingInfo(), m_lineShapeInfo->GetLineData());
   if (!m_isSimple)
diff --git a/drape_frontend/line_shape.hpp b/drape_frontend/line_shape.hpp
index f6ae996d21..8b56907468 100644
--- a/drape_frontend/line_shape.hpp
+++ b/drape_frontend/line_shape.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "drape_frontend/map_shape.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/shape_view_params.hpp"
 
 #include "drape/binding_info.hpp"
@@ -19,7 +19,7 @@ public:
   virtual ~ILineShapeInfo() {}
 
   virtual dp::BindingInfo const & GetBindingInfo() = 0;
-  virtual dp::GLState GetState() = 0;
+  virtual dp::RenderState GetState() = 0;
 
   virtual ref_ptr<void> GetLineData() = 0;
   virtual uint32_t GetLineSize() = 0;
@@ -28,7 +28,7 @@ public:
   virtual uint32_t GetJoinSize() = 0;
 
   virtual dp::BindingInfo const & GetCapBindingInfo() = 0;
-  virtual dp::GLState GetCapState() = 0;
+  virtual dp::RenderState GetCapState() = 0;
   virtual ref_ptr<void> GetCapData() = 0;
   virtual uint32_t GetCapSize() = 0;
 };
diff --git a/drape_frontend/message_subclasses.hpp b/drape_frontend/message_subclasses.hpp
index d021b29fb8..4967d07ab5 100644
--- a/drape_frontend/message_subclasses.hpp
+++ b/drape_frontend/message_subclasses.hpp
@@ -12,7 +12,7 @@
 #include "drape_frontend/my_position.hpp"
 #include "drape_frontend/overlay_batcher.hpp"
 #include "drape_frontend/postprocess_renderer.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/route_builder.hpp"
 #include "drape_frontend/selection_shape.hpp"
 #include "drape_frontend/tile_utils.hpp"
@@ -125,7 +125,7 @@ private:
 class FlushRenderBucketMessage : public BaseTileMessage
 {
 public:
-  FlushRenderBucketMessage(TileKey const & key, dp::GLState const & state,
+  FlushRenderBucketMessage(TileKey const & key, dp::RenderState const & state,
                            drape_ptr<dp::RenderBucket> && buffer)
     : BaseTileMessage(key)
     , m_state(state)
@@ -135,11 +135,11 @@ public:
   Type GetType() const override { return Message::FlushTile; }
   bool IsGLContextDependent() const override { return true; }
 
-  dp::GLState const & GetState() const { return m_state; }
+  dp::RenderState const & GetState() const { return m_state; }
   drape_ptr<dp::RenderBucket> && AcceptBuffer() { return move(m_buffer); }
 
 private:
-  dp::GLState m_state;
+  dp::RenderState m_state;
   drape_ptr<dp::RenderBucket> m_buffer;
 };
 
diff --git a/drape_frontend/my_position.cpp b/drape_frontend/my_position.cpp
index 67e1e77333..ee678588e7 100644
--- a/drape_frontend/my_position.cpp
+++ b/drape_frontend/my_position.cpp
@@ -167,13 +167,13 @@ void MyPosition::CacheAccuracySector(ref_ptr<dp::TextureManager> mng)
     buffer.emplace_back(nextNormal, colorCoord);
   }
 
-  auto state = CreateGLState(gpu::Program::Accuracy, RenderState::OverlayLayer);
+  auto state = CreateRenderState(gpu::Program::Accuracy, DepthLayer::OverlayLayer);
   state.SetDepthTestEnabled(false);
   state.SetColorTexture(color.GetTexture());
 
   {
     dp::Batcher batcher(kTriangleCount * dp::Batcher::IndexPerTriangle, kVertexCount);
-    dp::SessionGuard guard(batcher, [this](dp::GLState const & state, drape_ptr<dp::RenderBucket> && b)
+    dp::SessionGuard guard(batcher, [this](dp::RenderState const & state, drape_ptr<dp::RenderBucket> && b)
     {
       drape_ptr<dp::RenderBucket> bucket = std::move(b);
       ASSERT(bucket->GetOverlayHandlesCount() == 0, ());
@@ -191,7 +191,7 @@ void MyPosition::CacheAccuracySector(ref_ptr<dp::TextureManager> mng)
 }
 
 void MyPosition::CacheSymbol(dp::TextureManager::SymbolRegion const & symbol,
-                             dp::GLState const & state, dp::Batcher & batcher,
+                             dp::RenderState const & state, dp::Batcher & batcher,
                              EMyPositionPart part)
 {
   m2::RectF const & texRect = symbol.GetTexRect();
@@ -219,7 +219,7 @@ void MyPosition::CachePointPosition(ref_ptr<dp::TextureManager> mng)
 
   m_arrow3d.SetTexture(mng);
 
-  auto state = CreateGLState(gpu::Program::MyPosition, RenderState::OverlayLayer);
+  auto state = CreateRenderState(gpu::Program::MyPosition, DepthLayer::OverlayLayer);
   state.SetDepthTestEnabled(false);
   state.SetColorTexture(pointSymbol.GetTexture());
 
@@ -227,7 +227,7 @@ void MyPosition::CachePointPosition(ref_ptr<dp::TextureManager> mng)
   EMyPositionPart partIndices[kSymbolsCount] = { MyPositionPoint };
   {
     dp::Batcher batcher(kSymbolsCount * dp::Batcher::IndexPerQuad, kSymbolsCount * dp::Batcher::VertexPerQuad);
-    dp::SessionGuard guard(batcher, [this](dp::GLState const & state, drape_ptr<dp::RenderBucket> && b)
+    dp::SessionGuard guard(batcher, [this](dp::RenderState const & state, drape_ptr<dp::RenderBucket> && b)
     {
       drape_ptr<dp::RenderBucket> bucket = std::move(b);
       ASSERT(bucket->GetOverlayHandlesCount() == 0, ());
diff --git a/drape_frontend/my_position.hpp b/drape_frontend/my_position.hpp
index 21a7f4b5a3..164548d98b 100644
--- a/drape_frontend/my_position.hpp
+++ b/drape_frontend/my_position.hpp
@@ -3,7 +3,7 @@
 #include "drape_frontend/arrow3d.hpp"
 #include "drape_frontend/frame_values.hpp"
 #include "drape_frontend/render_node.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 
 #include "shaders/program_manager.hpp"
 
@@ -55,7 +55,7 @@ private:
                   EMyPositionPart part);
 
   void CacheSymbol(dp::TextureManager::SymbolRegion const & symbol,
-                   dp::GLState const & state, dp::Batcher & batcher,
+                   dp::RenderState const & state, dp::Batcher & batcher,
                    EMyPositionPart part);
 
   m2::PointF m_position;
diff --git a/drape_frontend/overlay_batcher.cpp b/drape_frontend/overlay_batcher.cpp
index 3f57510184..0afd4557b4 100644
--- a/drape_frontend/overlay_batcher.cpp
+++ b/drape_frontend/overlay_batcher.cpp
@@ -18,7 +18,7 @@ OverlayBatcher::OverlayBatcher(TileKey const & key)
   int const kAverageRenderDataCount = 5;
   m_data.reserve(kAverageRenderDataCount);
 
-  m_batcher.StartSession([this, key](dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket)
+  m_batcher.StartSession([this, key](dp::RenderState const & state, drape_ptr<dp::RenderBucket> && bucket)
   {
     FlushGeometry(key, state, move(bucket));
   });
@@ -36,7 +36,7 @@ void OverlayBatcher::Finish(TOverlaysRenderData & data)
   data.swap(m_data);
 }
 
-void OverlayBatcher::FlushGeometry(TileKey const & key, dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket)
+void OverlayBatcher::FlushGeometry(TileKey const & key, dp::RenderState const & state, drape_ptr<dp::RenderBucket> && bucket)
 {
   m_data.emplace_back(key, state, move(bucket));
 }
diff --git a/drape_frontend/overlay_batcher.hpp b/drape_frontend/overlay_batcher.hpp
index 45c1733ed8..3c0adcd2d8 100644
--- a/drape_frontend/overlay_batcher.hpp
+++ b/drape_frontend/overlay_batcher.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/tile_key.hpp"
 
 #include "drape/batcher.hpp"
@@ -22,10 +22,10 @@ class MapShape;
 struct OverlayRenderData
 {
   TileKey m_tileKey;
-  dp::GLState m_state;
+  dp::RenderState m_state;
   drape_ptr<dp::RenderBucket> m_bucket;
 
-  OverlayRenderData(TileKey const & key, dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket)
+  OverlayRenderData(TileKey const & key, dp::RenderState const & state, drape_ptr<dp::RenderBucket> && bucket)
     : m_tileKey(key), m_state(state), m_bucket(move(bucket))
   {}
 };
@@ -40,7 +40,7 @@ public:
   void Finish(TOverlaysRenderData & data);
 
 private:
-  void FlushGeometry(TileKey const & key, dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket);
+  void FlushGeometry(TileKey const & key, dp::RenderState const & state, drape_ptr<dp::RenderBucket> && bucket);
 
   dp::Batcher m_batcher;
   TOverlaysRenderData m_data;
diff --git a/drape_frontend/path_symbol_shape.cpp b/drape_frontend/path_symbol_shape.cpp
index 4d9ffa87c4..151010d1b9 100644
--- a/drape_frontend/path_symbol_shape.cpp
+++ b/drape_frontend/path_symbol_shape.cpp
@@ -1,5 +1,5 @@
 #include "drape_frontend/path_symbol_shape.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/visual_params.hpp"
 
 #include "shaders/programs.hpp"
@@ -53,7 +53,7 @@ void PathSymbolShape::Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureMana
   if (buffer.empty())
     return;
 
-  auto state = CreateGLState(gpu::Program::PathSymbol, RenderState::GeometryLayer);
+  auto state = CreateRenderState(gpu::Program::PathSymbol, DepthLayer::GeometryLayer);
   state.SetColorTexture(region.GetTexture());
   state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
 
diff --git a/drape_frontend/path_text_shape.cpp b/drape_frontend/path_text_shape.cpp
index 57b3d3fbb5..d8e046c715 100644
--- a/drape_frontend/path_text_shape.cpp
+++ b/drape_frontend/path_text_shape.cpp
@@ -1,6 +1,6 @@
 #include "drape_frontend/path_text_shape.hpp"
 #include "drape_frontend/path_text_handle.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 
 #include "shaders/programs.hpp"
 
@@ -82,9 +82,9 @@ void PathTextShape::DrawPathTextPlain(ref_ptr<dp::TextureManager> textures,
   dp::TextureManager::ColorRegion color;
   textures->GetColorRegion(m_params.m_textFont.m_color, color);
 
-  auto state = CreateGLState(layout->GetFixedHeight() > 0 ?
-                             gpu::Program::TextFixed : gpu::Program::Text,
-                             RenderState::OverlayLayer);
+  auto state = CreateRenderState(layout->GetFixedHeight() > 0 ?
+                                 gpu::Program::TextFixed : gpu::Program::Text,
+                                 DepthLayer::OverlayLayer);
   state.SetProgram3d(layout->GetFixedHeight() > 0 ?
                      gpu::Program::TextFixedBillboard : gpu::Program::TextBillboard);
   state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
@@ -124,7 +124,7 @@ void PathTextShape::DrawPathTextOutlined(ref_ptr<dp::TextureManager> textures,
   textures->GetColorRegion(m_params.m_textFont.m_color, color);
   textures->GetColorRegion(m_params.m_textFont.m_outlineColor, outline);
 
-  auto state = CreateGLState(gpu::Program::TextOutlined, RenderState::OverlayLayer);
+  auto state = CreateRenderState(gpu::Program::TextOutlined, DepthLayer::OverlayLayer);
   state.SetProgram3d(gpu::Program::TextOutlinedBillboard);
   state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
   state.SetColorTexture(color.GetTexture());
diff --git a/drape_frontend/poi_symbol_shape.cpp b/drape_frontend/poi_symbol_shape.cpp
index 038dbeba23..33d1c8f681 100644
--- a/drape_frontend/poi_symbol_shape.cpp
+++ b/drape_frontend/poi_symbol_shape.cpp
@@ -67,7 +67,7 @@ void Batch<SV>(ref_ptr<dp::Batcher> batcher, drape_ptr<dp::OverlayHandle> && han
         glsl::vec2(texRect.maxX(), texRect.minY()) },
   };
 
-  auto state = df::CreateGLState(gpu::Program::Texturing, params.m_depthLayer);
+  auto state = df::CreateRenderState(gpu::Program::Texturing, params.m_depthLayer);
   state.SetProgram3d(gpu::Program::TexturingBillboard);
   state.SetDepthTestEnabled(params.m_depthTestEnabled);
   state.SetColorTexture(symbolRegion.GetTexture());
@@ -101,7 +101,7 @@ void Batch<MV>(ref_ptr<dp::Batcher> batcher, drape_ptr<dp::OverlayHandle> && han
         glsl::vec2(texRect.maxX(), texRect.minY()), maskColorCoords },
   };
 
-  auto state = df::CreateGLState(gpu::Program::MaskedTexturing, params.m_depthLayer);
+  auto state = df::CreateRenderState(gpu::Program::MaskedTexturing, params.m_depthLayer);
   state.SetProgram3d(gpu::Program::MaskedTexturingBillboard);
   state.SetDepthTestEnabled(params.m_depthTestEnabled);
   state.SetColorTexture(symbolRegion.GetTexture());
diff --git a/drape_frontend/postprocess_renderer.cpp b/drape_frontend/postprocess_renderer.cpp
index e631756876..f1279174d1 100644
--- a/drape_frontend/postprocess_renderer.cpp
+++ b/drape_frontend/postprocess_renderer.cpp
@@ -1,5 +1,5 @@
 #include "drape_frontend/postprocess_renderer.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/screen_quad_renderer.hpp"
 
 #include "shaders/program_manager.hpp"
diff --git a/drape_frontend/render_group.cpp b/drape_frontend/render_group.cpp
index 02b45c82fe..74b74ce2e7 100755
--- a/drape_frontend/render_group.cpp
+++ b/drape_frontend/render_group.cpp
@@ -21,7 +21,7 @@ void BaseRenderGroup::UpdateAnimation()
   m_params.m_opacity = 1.0f;
 }
 
-RenderGroup::RenderGroup(dp::GLState const & state, df::TileKey const & tileKey)
+RenderGroup::RenderGroup(dp::RenderState const & state, df::TileKey const & tileKey)
   : TBase(state, tileKey)
   , m_pendingOnDelete(false)
   , m_canBeDeleted(false)
@@ -137,19 +137,19 @@ void RenderGroup::AddBucket(drape_ptr<dp::RenderBucket> && bucket)
 bool RenderGroup::IsOverlay() const
 {
   auto const depthLayer = GetDepthLayer(m_state);
-  return (depthLayer == RenderState::OverlayLayer) ||
-         (depthLayer == RenderState::NavigationLayer && HasOverlayHandles());
+  return (depthLayer == DepthLayer::OverlayLayer) ||
+         (depthLayer == DepthLayer::NavigationLayer && HasOverlayHandles());
 }
 
 bool RenderGroup::IsUserMark() const
 {
   auto const depthLayer = GetDepthLayer(m_state);
-  return depthLayer == RenderState::UserLineLayer ||
-         depthLayer == RenderState::UserMarkLayer ||
-         depthLayer == RenderState::TransitMarkLayer ||
-         depthLayer == RenderState::RoutingMarkLayer ||
-         depthLayer == RenderState::LocalAdsMarkLayer ||
-         depthLayer == RenderState::SearchMarkLayer;
+  return depthLayer == DepthLayer::UserLineLayer ||
+         depthLayer == DepthLayer::UserMarkLayer ||
+         depthLayer == DepthLayer::TransitMarkLayer ||
+         depthLayer == DepthLayer::RoutingMarkLayer ||
+         depthLayer == DepthLayer::LocalAdsMarkLayer ||
+         depthLayer == DepthLayer::SearchMarkLayer;
 }
 
 bool RenderGroup::UpdateCanBeDeletedStatus(bool canBeDeleted, int currentZoom, ref_ptr<dp::OverlayTree> tree)
@@ -195,7 +195,7 @@ bool RenderGroupComparator::operator()(drape_ptr<RenderGroup> const & l, drape_p
   return rCanBeDeleted;
 }
 
-UserMarkRenderGroup::UserMarkRenderGroup(dp::GLState const & state, TileKey const & tileKey)
+UserMarkRenderGroup::UserMarkRenderGroup(dp::RenderState const & state, TileKey const & tileKey)
   : TBase(state, tileKey)
 {
   auto const program = state.GetProgram<gpu::Program>();
diff --git a/drape_frontend/render_group.hpp b/drape_frontend/render_group.hpp
index c1c89bd32e..bc196c0ecb 100755
--- a/drape_frontend/render_group.hpp
+++ b/drape_frontend/render_group.hpp
@@ -3,7 +3,7 @@
 #include "drape_frontend/animation/opacity_animation.hpp"
 #include "drape_frontend/animation/value_mapping.hpp"
 #include "drape_frontend/frame_values.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/tile_utils.hpp"
 
 #include "shaders/program_params.hpp"
@@ -24,14 +24,14 @@ namespace df
 class BaseRenderGroup
 {
 public:
-  BaseRenderGroup(dp::GLState const & state, TileKey const & tileKey)
+  BaseRenderGroup(dp::RenderState const & state, TileKey const & tileKey)
     : m_state(state)
     , m_tileKey(tileKey)
   {}
 
   virtual ~BaseRenderGroup() = default;
 
-  dp::GLState const & GetState() const { return m_state; }
+  dp::RenderState const & GetState() const { return m_state; }
   TileKey const & GetTileKey() const { return m_tileKey; }
 
   virtual void UpdateAnimation();
@@ -39,7 +39,7 @@ public:
                       FrameValues const & frameValues) = 0;
 
 protected:
-  dp::GLState m_state;
+  dp::RenderState m_state;
   gpu::MapProgramParams m_params;
 
 private:
@@ -51,7 +51,7 @@ class RenderGroup : public BaseRenderGroup
   using TBase = BaseRenderGroup;
   friend class BatchMergeHelper;
 public:
-  RenderGroup(dp::GLState const & state, TileKey const & tileKey);
+  RenderGroup(dp::RenderState const & state, TileKey const & tileKey);
   ~RenderGroup() override;
 
   void Update(ScreenBase const & modelView);
@@ -97,7 +97,7 @@ class UserMarkRenderGroup : public RenderGroup
   using TBase = RenderGroup;
 
 public:
-  UserMarkRenderGroup(dp::GLState const & state, TileKey const & tileKey);
+  UserMarkRenderGroup(dp::RenderState const & state, TileKey const & tileKey);
   ~UserMarkRenderGroup() override {}
 
   void UpdateAnimation() override;
diff --git a/drape_frontend/render_node.hpp b/drape_frontend/render_node.hpp
index e80f41e765..c2f1de49b0 100644
--- a/drape_frontend/render_node.hpp
+++ b/drape_frontend/render_node.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 
 #include "shaders/program_manager.hpp"
 
@@ -12,7 +12,7 @@ namespace df
 class RenderNode
 {
 public:
-  RenderNode(dp::GLState const & state, drape_ptr<dp::VertexArrayBuffer> && buffer)
+  RenderNode(dp::RenderState const & state, drape_ptr<dp::VertexArrayBuffer> && buffer)
     : m_state(state)
     , m_buffer(std::move(buffer))
   {}
@@ -48,7 +48,7 @@ private:
     mng->GetParamsSetter()->Apply(prg, params);
   }
 
-  dp::GLState m_state;
+  dp::RenderState m_state;
   drape_ptr<dp::VertexArrayBuffer> m_buffer;
   bool m_isBuilt = false;
 };
diff --git a/drape_frontend/render_state.cpp b/drape_frontend/render_state.cpp
deleted file mode 100644
index ca59e03dae..0000000000
--- a/drape_frontend/render_state.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "drape_frontend/render_state.hpp"
-
-#include <vector>
-
-namespace df
-{
-RenderState::RenderState(DepthLayer depthLayer)
-  : m_depthLayer(depthLayer)
-{}
-
-bool RenderState::Less(ref_ptr<dp::BaseRenderState> other) const
-{
-  ASSERT(dynamic_cast<RenderState const *>(other.get()) != nullptr, ());
-  auto const renderState = static_cast<RenderState const *>(other.get());
-  return m_depthLayer < renderState->m_depthLayer;
-}
-
-bool RenderState::Equal(ref_ptr<dp::BaseRenderState> other) const
-{
-  ASSERT(dynamic_cast<RenderState const *>(other.get()) != nullptr, ());
-  auto const renderState = static_cast<RenderState const *>(other.get());
-  return m_depthLayer == renderState->m_depthLayer;
-}
-
-// static
-ref_ptr<RenderState> RenderStateFactory::Get(RenderState::DepthLayer depthLayer)
-{
-  static std::vector<drape_ptr<RenderState>> m_states;
-  if (m_states.empty())
-  {
-    m_states.reserve(RenderState::LayersCount);
-    for (size_t i = 0; i < RenderState::LayersCount; ++i)
-      m_states.emplace_back(make_unique_dp<RenderState>(static_cast<RenderState::DepthLayer>(i)));
-  }
-  return make_ref(m_states[static_cast<size_t>(depthLayer)]);
-}
-
-RenderState::DepthLayer GetDepthLayer(dp::GLState const & state)
-{
-  return state.GetRenderState<RenderState>()->GetDepthLayer();
-}
-
-dp::GLState CreateGLState(gpu::Program program, RenderState::DepthLayer depthLayer)
-{
-  return dp::GLState(program, RenderStateFactory::Get(depthLayer));
-}
-}  // namespace df
diff --git a/drape_frontend/render_state.hpp b/drape_frontend/render_state.hpp
deleted file mode 100644
index 1d4580170c..0000000000
--- a/drape_frontend/render_state.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-#include "shaders/programs.hpp"
-
-#include "drape/glstate.hpp"
-#include "drape/pointers.hpp"
-
-namespace df
-{
-class RenderState : public dp::BaseRenderState
-{
-public:
-  enum DepthLayer
-  {
-    // Do not change the order.
-    GeometryLayer = 0,
-    Geometry3dLayer,
-    UserLineLayer,
-    OverlayLayer,
-    LocalAdsMarkLayer,
-    TransitSchemeLayer,
-    UserMarkLayer,
-    NavigationLayer,
-    TransitMarkLayer,
-    RoutingMarkLayer,
-    SearchMarkLayer,
-    GuiLayer,
-    LayersCount
-  };
-
-  explicit RenderState(DepthLayer depthLayer);
-
-  bool Less(ref_ptr<dp::BaseRenderState> other) const override;
-  bool Equal(ref_ptr<dp::BaseRenderState> other) const override;
-
-  DepthLayer GetDepthLayer() const { return m_depthLayer; }
-
-private:
-  DepthLayer const m_depthLayer;
-};
-
-class RenderStateFactory
-{
-public:
-  static ref_ptr<RenderState> Get(RenderState::DepthLayer depthLayer);
-};
-
-extern RenderState::DepthLayer GetDepthLayer(dp::GLState const & state);
-extern dp::GLState CreateGLState(gpu::Program program, RenderState::DepthLayer depthLayer);
-}  // namespace df
diff --git a/drape_frontend/render_state_extension.cpp b/drape_frontend/render_state_extension.cpp
new file mode 100644
index 0000000000..edb98ffdd5
--- /dev/null
+++ b/drape_frontend/render_state_extension.cpp
@@ -0,0 +1,47 @@
+#include "drape_frontend/render_state_extension.hpp"
+
+#include <vector>
+
+namespace df
+{
+RenderStateExtension::RenderStateExtension(DepthLayer depthLayer)
+  : m_depthLayer(depthLayer)
+{}
+
+bool RenderStateExtension::Less(ref_ptr<dp::BaseRenderStateExtension> other) const
+{
+  ASSERT(dynamic_cast<RenderStateExtension const *>(other.get()) != nullptr, ());
+  auto const renderState = static_cast<RenderStateExtension const *>(other.get());
+  return m_depthLayer < renderState->m_depthLayer;
+}
+
+bool RenderStateExtension::Equal(ref_ptr<dp::BaseRenderStateExtension> other) const
+{
+  ASSERT(dynamic_cast<RenderStateExtension const *>(other.get()) != nullptr, ());
+  auto const renderState = static_cast<RenderStateExtension const *>(other.get());
+  return m_depthLayer == renderState->m_depthLayer;
+}
+
+// static
+ref_ptr<RenderStateExtension> RenderStateExtensionFactory::Get(DepthLayer depthLayer)
+{
+  static std::vector<drape_ptr<RenderStateExtension>> m_states;
+  if (m_states.empty())
+  {
+    m_states.reserve(static_cast<size_t>(DepthLayer::LayersCount));
+    for (size_t i = 0; i < static_cast<size_t>(DepthLayer::LayersCount); ++i)
+      m_states.emplace_back(make_unique_dp<RenderStateExtension>(static_cast<DepthLayer>(i)));
+  }
+  return make_ref(m_states[static_cast<size_t>(depthLayer)]);
+}
+
+DepthLayer GetDepthLayer(dp::RenderState const & state)
+{
+  return state.GetRenderStateExtension<RenderStateExtension>()->GetDepthLayer();
+}
+
+dp::RenderState CreateRenderState(gpu::Program program, DepthLayer depthLayer)
+{
+  return dp::RenderState(program, RenderStateExtensionFactory::Get(depthLayer));
+}
+}  // namespace df
diff --git a/drape_frontend/render_state_extension.hpp b/drape_frontend/render_state_extension.hpp
new file mode 100644
index 0000000000..9986610c8a
--- /dev/null
+++ b/drape_frontend/render_state_extension.hpp
@@ -0,0 +1,52 @@
+#pragma once
+
+#include "shaders/programs.hpp"
+
+#include "drape/pointers.hpp"
+#include "drape/render_state.hpp"
+
+#include <cstdint>
+
+namespace df
+{
+enum class DepthLayer : uint8_t
+{
+  // Do not change the order.
+  GeometryLayer = 0,
+  Geometry3dLayer,
+  UserLineLayer,
+  OverlayLayer,
+  LocalAdsMarkLayer,
+  TransitSchemeLayer,
+  UserMarkLayer,
+  NavigationLayer,
+  TransitMarkLayer,
+  RoutingMarkLayer,
+  SearchMarkLayer,
+  GuiLayer,
+  LayersCount
+};
+
+class RenderStateExtension : public dp::BaseRenderStateExtension
+{
+public:
+  explicit RenderStateExtension(DepthLayer depthLayer);
+
+  bool Less(ref_ptr<dp::BaseRenderStateExtension> other) const override;
+  bool Equal(ref_ptr<dp::BaseRenderStateExtension> other) const override;
+
+  DepthLayer GetDepthLayer() const { return m_depthLayer; }
+
+private:
+  DepthLayer const m_depthLayer;
+};
+
+class RenderStateExtensionFactory
+{
+public:
+  static ref_ptr<RenderStateExtension> Get(DepthLayer depthLayer);
+};
+
+extern DepthLayer GetDepthLayer(dp::RenderState const & state);
+extern dp::RenderState CreateRenderState(gpu::Program program, DepthLayer depthLayer);
+}  // namespace df
diff --git a/drape_frontend/route_renderer.cpp b/drape_frontend/route_renderer.cpp
index accceee5cb..985a9b5abd 100644
--- a/drape_frontend/route_renderer.cpp
+++ b/drape_frontend/route_renderer.cpp
@@ -403,7 +403,7 @@ void RouteRenderer::RenderSubroute(SubrouteInfo const & subrouteInfo, size_t sub
     dist = static_cast<float>(m_distanceFromBegin - distanceOffset);
   }
 
-  dp::GLState const & state = subrouteData->m_renderProperty.m_state;
+  dp::RenderState const & state = subrouteData->m_renderProperty.m_state;
   size_t const styleIndex = subrouteData->m_styleIndex;
   ASSERT_LESS(styleIndex, subrouteInfo.m_subroute->m_style.size(), ());
   auto const & style = subrouteInfo.m_subroute->m_style[styleIndex];
@@ -451,7 +451,7 @@ void RouteRenderer::RenderSubrouteArrows(SubrouteInfo const & subrouteInfo,
     return;
   }
 
-  dp::GLState const & state = subrouteInfo.m_arrowsData->m_renderProperty.m_state;
+  dp::RenderState const & state = subrouteInfo.m_arrowsData->m_renderProperty.m_state;
   float const currentHalfWidth = GetCurrentHalfWidth(subrouteInfo);
 
   // Set up parameters.
@@ -490,7 +490,7 @@ void RouteRenderer::RenderSubrouteMarkers(SubrouteInfo const & subrouteInfo, Scr
   if (m_followingEnabled)
     dist = static_cast<float>(m_distanceFromBegin - subrouteInfo.m_subroute->m_baseDistance);
 
-  dp::GLState const & state = subrouteInfo.m_markersData->m_renderProperty.m_state;
+  dp::RenderState const & state = subrouteInfo.m_markersData->m_renderProperty.m_state;
   float const currentHalfWidth = GetCurrentHalfWidth(subrouteInfo);
 
   // Set up parameters.
@@ -528,7 +528,7 @@ void RouteRenderer::RenderPreviewData(ScreenBase const & screen, ref_ptr<gpu::Pr
   ref_ptr<dp::GpuProgram> program = mng->GetProgram(gpu::Program::CirclePoint);
   program->Bind();
 
-  dp::GLState const & state = m_previewRenderData.front()->m_state;
+  dp::RenderState const & state = m_previewRenderData.front()->m_state;
   dp::ApplyState(state, program);
   mng->GetParamsSetter()->Apply(program, params);
 
diff --git a/drape_frontend/route_shape.cpp b/drape_frontend/route_shape.cpp
index 117202302f..6728be0f19 100644
--- a/drape_frontend/route_shape.cpp
+++ b/drape_frontend/route_shape.cpp
@@ -490,7 +490,7 @@ void RouteShape::CacheRouteArrows(ref_ptr<dp::TextureManager> mng, m2::PolylineD
   TArrowGeometryBuffer joinsGeometry;
   dp::TextureManager::SymbolRegion region;
   GetArrowTextureRegion(mng, region);
-  auto state = CreateGLState(gpu::Program::RouteArrow, RenderState::GeometryLayer);
+  auto state = CreateRenderState(gpu::Program::RouteArrow, DepthLayer::GeometryLayer);
   state.SetColorTexture(region.GetTexture());
 
   // Generate arrow geometry.
@@ -566,8 +566,8 @@ drape_ptr<df::SubrouteData> RouteShape::CacheRoute(dp::DrapeID subrouteId, Subro
                   static_cast<float>(subroute->m_baseDepthIndex * kDepthPerSubroute),
                   geometry, joinsGeometry);
 
-  auto state = CreateGLState(subroute->m_style[styleIndex].m_pattern.m_isDashed ?
-                             gpu::Program::RouteDash : gpu::Program::Route, RenderState::GeometryLayer);
+  auto state = CreateRenderState(subroute->m_style[styleIndex].m_pattern.m_isDashed ?
+                                 gpu::Program::RouteDash : gpu::Program::Route, DepthLayer::GeometryLayer);
   state.SetColorTexture(textures->GetSymbolsTexture());
 
   BatchGeometry(state, make_ref(geometry.data()), static_cast<uint32_t>(geometry.size()),
@@ -595,14 +595,14 @@ drape_ptr<df::SubrouteMarkersData> RouteShape::CacheMarkers(dp::DrapeID subroute
   if (geometry.empty())
     return nullptr;
 
-  auto state = CreateGLState(gpu::Program::RouteMarker, RenderState::GeometryLayer);
+  auto state = CreateRenderState(gpu::Program::RouteMarker, DepthLayer::GeometryLayer);
   state.SetColorTexture(textures->GetSymbolsTexture());
 
   // Batching.
   {
     uint32_t const kBatchSize = 200;
     dp::Batcher batcher(kBatchSize, kBatchSize);
-    dp::SessionGuard guard(batcher, [&markersData](dp::GLState const & state,
+    dp::SessionGuard guard(batcher, [&markersData](dp::RenderState const & state,
                                                    drape_ptr<dp::RenderBucket> &&b)
     {
       markersData->m_renderProperty.m_buckets.push_back(std::move(b));
@@ -617,7 +617,7 @@ drape_ptr<df::SubrouteMarkersData> RouteShape::CacheMarkers(dp::DrapeID subroute
   return markersData;
 }
 
-void RouteShape::BatchGeometry(dp::GLState const & state, ref_ptr<void> geometry, uint32_t geomSize,
+void RouteShape::BatchGeometry(dp::RenderState const & state, ref_ptr<void> geometry, uint32_t geomSize,
                                ref_ptr<void> joinsGeometry, uint32_t joinsGeomSize,
                                dp::BindingInfo const & bindingInfo, RouteRenderProperty & property)
 {
@@ -627,7 +627,7 @@ void RouteShape::BatchGeometry(dp::GLState const & state, ref_ptr<void> geometry
 
   uint32_t const kBatchSize = 5000;
   dp::Batcher batcher(kBatchSize, kBatchSize);
-  dp::SessionGuard guard(batcher, [&property](dp::GLState const & state, drape_ptr<dp::RenderBucket> && b)
+  dp::SessionGuard guard(batcher, [&property](dp::RenderState const & state, drape_ptr<dp::RenderBucket> && b)
   {
     property.m_buckets.push_back(std::move(b));
     property.m_state = state;
diff --git a/drape_frontend/route_shape.hpp b/drape_frontend/route_shape.hpp
index 9a4a6dce9f..3db03d22dc 100644
--- a/drape_frontend/route_shape.hpp
+++ b/drape_frontend/route_shape.hpp
@@ -2,7 +2,7 @@
 
 #include "drape_frontend/color_constants.hpp"
 #include "drape_frontend/map_shape.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/shape_view_params.hpp"
 
 #include "drape/render_bucket.hpp"
@@ -157,10 +157,10 @@ using SubrouteConstPtr = std::shared_ptr<Subroute const>;
 
 struct RouteRenderProperty
 {
-  dp::GLState m_state;
+  dp::RenderState m_state;
   std::vector<drape_ptr<dp::RenderBucket>> m_buckets;
   RouteRenderProperty()
-    : m_state(CreateGLState(gpu::Program::Route, RenderState::GeometryLayer))
+    : m_state(CreateRenderState(gpu::Program::Route, DepthLayer::GeometryLayer))
   {}
 };
 
@@ -226,7 +226,7 @@ private:
                                      m2::PointD const & pivot, float baseDepth,
                                      TMarkersGeometryBuffer & geometry);
 
-  static void BatchGeometry(dp::GLState const & state, ref_ptr<void> geometry, uint32_t geomSize,
+  static void BatchGeometry(dp::RenderState const & state, ref_ptr<void> geometry, uint32_t geomSize,
                             ref_ptr<void> joinsGeometry, uint32_t joinsGeomSize,
                             dp::BindingInfo const & bindingInfo, RouteRenderProperty & property);
 };
diff --git a/drape_frontend/rule_drawer.cpp b/drape_frontend/rule_drawer.cpp
index 57493c4e41..0192754614 100644
--- a/drape_frontend/rule_drawer.cpp
+++ b/drape_frontend/rule_drawer.cpp
@@ -441,9 +441,9 @@ void RuleDrawer::ProcessPointStyle(FeatureType & f, Stylist const & s,
   if (isSpeedCamera && !GetStyleReader().IsCarNavigationStyle())
     return;
 
-  RenderState::DepthLayer depthLayer = RenderState::OverlayLayer;
+  DepthLayer depthLayer = DepthLayer::OverlayLayer;
   if (isSpeedCamera)
-    depthLayer = RenderState::NavigationLayer;
+    depthLayer = DepthLayer::NavigationLayer;
 
   minVisibleScale = feature::GetMinDrawableScale(f);
   ApplyPointFeature apply(m_context->GetTileKey(), insertShape, f.GetID(), minVisibleScale, f.GetRank(),
@@ -553,7 +553,7 @@ void RuleDrawer::DrawTileNet(TInsertShapeFn const & insertShape)
   p.m_cap = dp::ButtCap;
   p.m_color = dp::Color::Red();
   p.m_depth = 20000;
-  p.m_depthLayer = RenderState::GeometryLayer;
+  p.m_depthLayer = DepthLayer::GeometryLayer;
   p.m_width = 5;
   p.m_join = dp::RoundJoin;
 
@@ -563,7 +563,7 @@ void RuleDrawer::DrawTileNet(TInsertShapeFn const & insertShape)
   tp.m_tileCenter = m_globalRect.Center();
   tp.m_titleDecl.m_anchor = dp::Center;
   tp.m_depth = 20000;
-  tp.m_depthLayer = RenderState::OverlayLayer;
+  tp.m_depthLayer = DepthLayer::OverlayLayer;
   tp.m_titleDecl.m_primaryText = strings::to_string(key.m_x) + " " +
                                  strings::to_string(key.m_y) + " " +
                                  strings::to_string(key.m_zoomLevel);
diff --git a/drape_frontend/screen_quad_renderer.cpp b/drape_frontend/screen_quad_renderer.cpp
index 836309e6d0..80cfff7e9a 100644
--- a/drape_frontend/screen_quad_renderer.cpp
+++ b/drape_frontend/screen_quad_renderer.cpp
@@ -1,5 +1,5 @@
 #include "drape_frontend/screen_quad_renderer.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 
 #include "shaders/program_manager.hpp"
 
diff --git a/drape_frontend/selection_shape.cpp b/drape_frontend/selection_shape.cpp
index deb55c7cab..7bbb7fb379 100644
--- a/drape_frontend/selection_shape.cpp
+++ b/drape_frontend/selection_shape.cpp
@@ -83,13 +83,13 @@ SelectionShape::SelectionShape(ref_ptr<dp::TextureManager> mng)
     buffer.emplace_back(nextNormal, colorCoord);
   }
 
-  auto state = CreateGLState(gpu::Program::Accuracy, RenderState::OverlayLayer);
+  auto state = CreateRenderState(gpu::Program::Accuracy, DepthLayer::OverlayLayer);
   state.SetColorTexture(color.GetTexture());
   state.SetDepthTestEnabled(false);
 
   {
     dp::Batcher batcher(kTriangleCount * dp::Batcher::IndexPerTriangle, kVertexCount);
-    dp::SessionGuard guard(batcher, [this](dp::GLState const & state, drape_ptr<dp::RenderBucket> && b)
+    dp::SessionGuard guard(batcher, [this](dp::RenderState const & state, drape_ptr<dp::RenderBucket> && b)
     {
       drape_ptr<dp::RenderBucket> bucket = std::move(b);
       ASSERT(bucket->GetOverlayHandlesCount() == 0, ());
diff --git a/drape_frontend/shape_view_params.hpp b/drape_frontend/shape_view_params.hpp
index 0fc2156805..77db25a0df 100644
--- a/drape_frontend/shape_view_params.hpp
+++ b/drape_frontend/shape_view_params.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 
 #include "drape/color.hpp"
 #include "drape/drape_global.hpp"
@@ -21,7 +21,7 @@ uint32_t constexpr kStartUserMarkOverlayIndex = 1000;
 
 struct CommonViewParams
 {
-  RenderState::DepthLayer m_depthLayer = RenderState::GeometryLayer;
+  DepthLayer m_depthLayer = DepthLayer::GeometryLayer;
   float m_depth = 0.0f;
   bool m_depthTestEnabled = true;
   int m_minVisibleScale = 0;
diff --git a/drape_frontend/text_shape.cpp b/drape_frontend/text_shape.cpp
index 2df3ce6b42..c7d24eba04 100644
--- a/drape_frontend/text_shape.cpp
+++ b/drape_frontend/text_shape.cpp
@@ -1,5 +1,5 @@
 #include "drape_frontend/text_shape.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/text_handle.hpp"
 #include "drape_frontend/text_layout.hpp"
 #include "drape_frontend/visual_params.hpp"
@@ -315,7 +315,7 @@ void TextShape::DrawSubStringPlain(StraightTextLayout const & layout, dp::FontDe
   layout.CacheStaticGeometry(color, staticBuffer);
 
   bool const isNonSdfText = layout.GetFixedHeight() > 0;
-  auto state = CreateGLState(isNonSdfText ? gpu::Program::TextFixed : gpu::Program::Text, m_params.m_depthLayer);
+  auto state = CreateRenderState(isNonSdfText ? gpu::Program::TextFixed : gpu::Program::Text, m_params.m_depthLayer);
   state.SetProgram3d(isNonSdfText ? gpu::Program::TextFixedBillboard : gpu::Program::TextBillboard);
   state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
 
@@ -381,7 +381,7 @@ void TextShape::DrawSubStringOutlined(StraightTextLayout const & layout, dp::Fon
   layout.CacheDynamicGeometry(finalOffset, dynamicBuffer);
   layout.CacheStaticGeometry(color, outline, staticBuffer);
 
-  auto state = CreateGLState(gpu::Program::TextOutlined, m_params.m_depthLayer);
+  auto state = CreateRenderState(gpu::Program::TextOutlined, m_params.m_depthLayer);
   state.SetProgram3d(gpu::Program::TextOutlinedBillboard);
   state.SetDepthTestEnabled(m_params.m_depthTestEnabled);
   ASSERT(color.GetTexture() == outline.GetTexture(), ());
diff --git a/drape_frontend/traffic_generator.cpp b/drape_frontend/traffic_generator.cpp
index 4d6b691c04..02f9918c74 100644
--- a/drape_frontend/traffic_generator.cpp
+++ b/drape_frontend/traffic_generator.cpp
@@ -147,15 +147,15 @@ void TrafficGenerator::GenerateSegmentsGeometry(MwmSet::MwmId const & mwmId, Til
   ASSERT(m_colorsCacheValid, ());
   auto const colorTexture = m_colorsCache[static_cast<size_t>(traffic::SpeedGroup::G0)].GetTexture();
 
-  auto state = CreateGLState(gpu::Program::Traffic, RenderState::GeometryLayer);
+  auto state = CreateRenderState(gpu::Program::Traffic, DepthLayer::GeometryLayer);
   state.SetColorTexture(colorTexture);
   state.SetMaskTexture(texturesMgr->GetTrafficArrowTexture());
 
-  auto lineState = CreateGLState(gpu::Program::TrafficLine, RenderState::GeometryLayer);
+  auto lineState = CreateRenderState(gpu::Program::TrafficLine, DepthLayer::GeometryLayer);
   lineState.SetColorTexture(colorTexture);
   lineState.SetDrawAsLine(true);
 
-  auto circleState = CreateGLState(gpu::Program::TrafficCircle, RenderState::GeometryLayer);
+  auto circleState = CreateRenderState(gpu::Program::TrafficCircle, DepthLayer::GeometryLayer);
   circleState.SetColorTexture(colorTexture);
 
   bool isLeftHand = false;
@@ -196,7 +196,7 @@ void TrafficGenerator::GenerateSegmentsGeometry(MwmSet::MwmId const & mwmId, Til
       m_providerLines.Reset(static_cast<uint32_t>(staticGeometry.size()));
       m_providerLines.UpdateStream(0 /* stream index */, make_ref(staticGeometry.data()));
 
-      dp::GLState curLineState = lineState;
+      dp::RenderState curLineState = lineState;
       curLineState.SetLineWidth(width);
       batcher->InsertLineStrip(curLineState, make_ref(&m_providerLines));
     }
@@ -244,7 +244,7 @@ void TrafficGenerator::FlushSegmentsGeometry(TileKey const & tileKey, TrafficSeg
     for (auto const & roadClass : kRoadClasses)
       m_batchersPool->ReserveBatcher(TrafficBatcherKey(mwmId, tileKey, roadClass));
 
-    m_circlesBatcher->StartSession([this, mwmId, tileKey](dp::GLState const & state,
+    m_circlesBatcher->StartSession([this, mwmId, tileKey](dp::RenderState const & state,
                                                           drape_ptr<dp::RenderBucket> && renderBucket)
     {
       FlushGeometry(TrafficBatcherKey(mwmId, tileKey, RoadClass::Class0), state,
@@ -284,7 +284,7 @@ void TrafficGenerator::InvalidateTexturesCache()
   m_colorsCacheValid = false;
 }
 
-void TrafficGenerator::FlushGeometry(TrafficBatcherKey const & key, dp::GLState const & state,
+void TrafficGenerator::FlushGeometry(TrafficBatcherKey const & key, dp::RenderState const & state,
                                      drape_ptr<dp::RenderBucket> && buffer)
 {
   TrafficRenderData renderData(state);
diff --git a/drape_frontend/traffic_generator.hpp b/drape_frontend/traffic_generator.hpp
index 5e5dea5a07..01c2336070 100644
--- a/drape_frontend/traffic_generator.hpp
+++ b/drape_frontend/traffic_generator.hpp
@@ -2,7 +2,7 @@
 
 #include "drape_frontend/batchers_pool.hpp"
 #include "drape_frontend/color_constants.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/tile_key.hpp"
 
 #include "drape/color.hpp"
@@ -84,13 +84,13 @@ using TrafficSegmentsColoring = std::map<MwmSet::MwmId, traffic::TrafficInfo::Co
 
 struct TrafficRenderData
 {
-  dp::GLState m_state;
+  dp::RenderState m_state;
   drape_ptr<dp::RenderBucket> m_bucket;
   TileKey m_tileKey;
   MwmSet::MwmId m_mwmId;
   RoadClass m_roadClass = RoadClass::Class0;
 
-  explicit TrafficRenderData(dp::GLState const & state) : m_state(state) {}
+  explicit TrafficRenderData(dp::RenderState const & state) : m_state(state) {}
 
   bool operator<(TrafficRenderData const & renderData) const
   {
@@ -221,7 +221,7 @@ private:
                            std::vector<TrafficLineStaticVertex> & staticGeometry);
   void FillColorsCache(ref_ptr<dp::TextureManager> textures);
 
-  void FlushGeometry(TrafficBatcherKey const & key, dp::GLState const & state,
+  void FlushGeometry(TrafficBatcherKey const & key, dp::RenderState const & state,
                      drape_ptr<dp::RenderBucket> && buffer);
   void GenerateSegmentsGeometry(MwmSet::MwmId const & mwmId, TileKey const & tileKey,
                                 TrafficSegmentsGeometryValue const & geometry,
diff --git a/drape_frontend/transit_scheme_builder.cpp b/drape_frontend/transit_scheme_builder.cpp
index 1c6c7b4898..6d1be76933 100644
--- a/drape_frontend/transit_scheme_builder.cpp
+++ b/drape_frontend/transit_scheme_builder.cpp
@@ -4,7 +4,7 @@
 #include "drape_frontend/colored_symbol_shape.hpp"
 #include "drape_frontend/line_shape_helper.hpp"
 #include "drape_frontend/map_shape.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/shape_view_params.hpp"
 #include "drape_frontend/text_layout.hpp"
 #include "drape_frontend/text_shape.hpp"
@@ -123,7 +123,7 @@ void GenerateLineCaps(std::vector<SchemeSegment> const & segments, glsl::vec4 co
 
   dp::AttributeProvider provider(1 /* stream count */, static_cast<uint32_t>(geometry.size()));
   provider.InitStream(0 /* stream index */, GetTransitStaticBindingInfo(), make_ref(geometry.data()));
-  auto state = CreateGLState(gpu::Program::TransitCircle, RenderState::TransitSchemeLayer);
+  auto state = CreateRenderState(gpu::Program::TransitCircle, DepthLayer::TransitSchemeLayer);
   batcher.InsertTriangleList(state, make_ref(&provider));
 }
 
@@ -540,7 +540,7 @@ void TransitSchemeBuilder::GenerateShapes(MwmSet::MwmId const & mwmId)
   uint32_t const kBatchSize = 5000;
   dp::Batcher batcher(kBatchSize, kBatchSize);
   {
-    dp::SessionGuard guard(batcher, [this, &mwmId, &scheme](dp::GLState const & state, drape_ptr<dp::RenderBucket> && b)
+    dp::SessionGuard guard(batcher, [this, &mwmId, &scheme](dp::RenderState const & state, drape_ptr<dp::RenderBucket> && b)
     {
       TransitRenderData::Type type = TransitRenderData::Type::Lines;
       if (state.GetProgram<gpu::Program>() == gpu::Program::TransitCircle)
@@ -587,7 +587,7 @@ void TransitSchemeBuilder::GenerateStops(MwmSet::MwmId const & mwmId, ref_ptr<dp
 {
   MwmSchemeData const & scheme = m_schemes[mwmId];
 
-  auto const flusher = [this, &mwmId, &scheme](dp::GLState const & state, drape_ptr<dp::RenderBucket> && b)
+  auto const flusher = [this, &mwmId, &scheme](dp::RenderState const & state, drape_ptr<dp::RenderBucket> && b)
   {
     TransitRenderData::Type type = TransitRenderData::Type::Stubs;
     if (state.GetProgram<gpu::Program>() == gpu::Program::TransitMarker)
@@ -730,7 +730,7 @@ void TransitSchemeBuilder::GenerateTitles(StopNodeParams const & stopParams, m2:
     textParams.m_titleDecl.m_primaryText = title.m_text;
     textParams.m_titleDecl.m_anchor = title.m_anchor;
     textParams.m_depthTestEnabled = false;
-    textParams.m_depthLayer = RenderState::TransitSchemeLayer;
+    textParams.m_depthLayer = DepthLayer::TransitSchemeLayer;
     textParams.m_specialDisplacement = SpecialDisplacement::TransitScheme;
     textParams.m_specialPriority = priority;
     textParams.m_startOverlayRank = dp::OverlayRank0;
@@ -746,7 +746,7 @@ void TransitSchemeBuilder::GenerateTitles(StopNodeParams const & stopParams, m2:
   colorParams.m_featureID = featureId;
   colorParams.m_tileCenter = pivot;
   colorParams.m_depthTestEnabled = false;
-  colorParams.m_depthLayer = RenderState::TransitSchemeLayer;
+  colorParams.m_depthLayer = DepthLayer::TransitSchemeLayer;
   colorParams.m_specialDisplacement = SpecialDisplacement::TransitScheme;
   colorParams.m_specialPriority = static_cast<uint16_t>(Priority::Stub);
   colorParams.m_startOverlayRank = dp::OverlayRank0;
@@ -787,7 +787,7 @@ void TransitSchemeBuilder::GenerateMarker(m2::PointD const & pt, m2::PointD widt
 
   dp::AttributeProvider provider(1 /* stream count */, static_cast<uint32_t>(geometry.size()));
   provider.InitStream(0 /* stream index */, GetTransitStaticBindingInfo(), make_ref(geometry.data()));
-  auto state = CreateGLState(gpu::Program::TransitMarker, RenderState::TransitSchemeLayer);
+  auto state = CreateRenderState(gpu::Program::TransitMarker, DepthLayer::TransitSchemeLayer);
   batcher.InsertTriangleList(state, make_ref(&provider));
 }
 
@@ -833,7 +833,7 @@ void TransitSchemeBuilder::GenerateLine(std::vector<m2::PointD> const & path, m2
 
   dp::AttributeProvider provider(1 /* stream count */, static_cast<uint32_t>(geometry.size()));
   provider.InitStream(0 /* stream index */, GetTransitStaticBindingInfo(), make_ref(geometry.data()));
-  auto state = CreateGLState(gpu::Program::Transit, RenderState::TransitSchemeLayer);
+  auto state = CreateRenderState(gpu::Program::Transit, DepthLayer::TransitSchemeLayer);
   batcher.InsertTriangleList(state, make_ref(&provider));
 
   GenerateLineCaps(segments, color, lineOffset, halfWidth, depth, batcher);
diff --git a/drape_frontend/transit_scheme_builder.hpp b/drape_frontend/transit_scheme_builder.hpp
index 3cb42aa630..0d09b3d9e1 100644
--- a/drape_frontend/transit_scheme_builder.hpp
+++ b/drape_frontend/transit_scheme_builder.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
 #include "drape/batcher.hpp"
-#include "drape/glstate.hpp"
 #include "drape/render_bucket.hpp"
+#include "drape/render_state.hpp"
 #include "drape/texture_manager.hpp"
 
 #include "transit/transit_display_info.hpp"
@@ -30,13 +30,13 @@ struct TransitRenderData
   };
 
   Type m_type;
-  dp::GLState m_state;
+  dp::RenderState m_state;
   uint32_t m_recacheId;
   MwmSet::MwmId m_mwmId;
   m2::PointD m_pivot;
   drape_ptr<dp::RenderBucket> m_bucket;
 
-  TransitRenderData(Type type, dp::GLState const & state, uint32_t recacheId, MwmSet::MwmId const & mwmId,
+  TransitRenderData(Type type, dp::RenderState const & state, uint32_t recacheId, MwmSet::MwmId const & mwmId,
                     m2::PointD const pivot, drape_ptr<dp::RenderBucket> && bucket)
     : m_type(type)
     , m_state(state)
diff --git a/drape_frontend/user_mark_generator.cpp b/drape_frontend/user_mark_generator.cpp
index c84bf19ebd..4d930b9dad 100644
--- a/drape_frontend/user_mark_generator.cpp
+++ b/drape_frontend/user_mark_generator.cpp
@@ -230,7 +230,7 @@ void UserMarkGenerator::GenerateUserMarksGeometry(TileKey const & tileKey, ref_p
   dp::Batcher batcher(kMaxSize, kMaxSize);
   TUserMarksRenderData renderData;
   {
-    dp::SessionGuard guard(batcher, [&tileKey, &renderData](dp::GLState const & state,
+    dp::SessionGuard guard(batcher, [&tileKey, &renderData](dp::RenderState const & state,
                                                            drape_ptr<dp::RenderBucket> && b)
     {
       renderData.emplace_back(state, std::move(b), tileKey);
diff --git a/drape_frontend/user_mark_shapes.cpp b/drape_frontend/user_mark_shapes.cpp
index f667a1fa5b..91b04ed6bf 100644
--- a/drape_frontend/user_mark_shapes.cpp
+++ b/drape_frontend/user_mark_shapes.cpp
@@ -300,7 +300,7 @@ void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> texture
 
   dp::TextureManager::SymbolRegion region;
   dp::TextureManager::SymbolRegion backgroundRegion;
-  RenderState::DepthLayer depthLayer = RenderState::UserMarkLayer;
+  DepthLayer depthLayer = DepthLayer::UserMarkLayer;
   bool depthTestEnabled = true;
   for (auto const id : marksId)
   {
@@ -409,8 +409,8 @@ void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> texture
 
   if (!buffer.empty())
   {
-    auto state = CreateGLState(isAnimated ? gpu::Program::BookmarkAnim
-                                          : gpu::Program::Bookmark, depthLayer);
+    auto state = CreateRenderState(isAnimated ? gpu::Program::BookmarkAnim
+                                              : gpu::Program::Bookmark, depthLayer);
     state.SetProgram3d(isAnimated ? gpu::Program::BookmarkAnimBillboard
                                   : gpu::Program::BookmarkBillboard);
     state.SetColorTexture(region.GetTexture());
diff --git a/drape_frontend/user_mark_shapes.hpp b/drape_frontend/user_mark_shapes.hpp
index 716e2f7145..05881cf678 100644
--- a/drape_frontend/user_mark_shapes.hpp
+++ b/drape_frontend/user_mark_shapes.hpp
@@ -33,7 +33,7 @@ struct UserMarkRenderParams
   uint32_t m_index = 0;
   bool m_depthTestEnabled = true;
   float m_depth = 0.0;
-  RenderState::DepthLayer m_depthLayer = RenderState::UserMarkLayer;
+  DepthLayer m_depthLayer = DepthLayer::UserMarkLayer;
   bool m_hasCreationAnimation = false;
   bool m_justCreated = false;
   bool m_isVisible = true;
@@ -57,7 +57,7 @@ struct LineLayer
 struct UserLineRenderParams
 {
   int m_minZoom = 1;
-  RenderState::DepthLayer m_depthLayer = RenderState::UserLineLayer;
+  DepthLayer m_depthLayer = DepthLayer::UserLineLayer;
   std::vector<LineLayer> m_layers;
   m2::SharedSpline m_spline;
 };
@@ -67,13 +67,13 @@ using UserLinesRenderCollection = std::unordered_map<kml::MarkId, drape_ptr<User
 
 struct UserMarkRenderData
 {
-  UserMarkRenderData(dp::GLState const & state,
+  UserMarkRenderData(dp::RenderState const & state,
                      drape_ptr<dp::RenderBucket> && bucket,
                      TileKey const & tileKey)
     : m_state(state), m_bucket(move(bucket)), m_tileKey(tileKey)
   {}
 
-  dp::GLState m_state;
+  dp::RenderState m_state;
   drape_ptr<dp::RenderBucket> m_bucket;
   TileKey m_tileKey;
 };
diff --git a/drape_frontend/user_marks_provider.hpp b/drape_frontend/user_marks_provider.hpp
index b4933a4baf..857dc7a725 100644
--- a/drape_frontend/user_marks_provider.hpp
+++ b/drape_frontend/user_marks_provider.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "drape_frontend/color_constants.hpp"
-#include "drape_frontend/render_state.hpp"
+#include "drape_frontend/render_state_extension.hpp"
 #include "drape_frontend/shape_view_params.hpp"
 
 #include "drape/drape_global.hpp"
@@ -57,7 +57,7 @@ public:
   virtual dp::Anchor GetAnchor() const = 0;
   virtual bool GetDepthTestEnabled() const = 0;
   virtual float GetDepth() const = 0;
-  virtual RenderState::DepthLayer GetDepthLayer() const = 0;
+  virtual DepthLayer GetDepthLayer() const = 0;
   virtual bool IsVisible() const = 0;
   virtual drape_ptr<TitlesInfo> GetTitleDecl() const = 0;
   virtual drape_ptr<SymbolNameZoomInfo> GetSymbolNames() const = 0;
@@ -91,7 +91,7 @@ public:
   virtual kml::TrackId GetId() const { return m_id; }
 
   virtual int GetMinZoom() const = 0;
-  virtual RenderState::DepthLayer GetDepthLayer() const = 0;
+  virtual DepthLayer GetDepthLayer() const = 0;
   virtual size_t GetLayerCount() const = 0;
   virtual dp::Color GetColor(size_t layerIndex) const = 0;
   virtual float GetWidth(size_t layerIndex) const = 0;
diff --git a/map/local_ads_mark.cpp b/map/local_ads_mark.cpp
index b01ea95197..40d111ec56 100644
--- a/map/local_ads_mark.cpp
+++ b/map/local_ads_mark.cpp
@@ -36,9 +36,9 @@ drape_ptr<df::UserPointMark::SymbolNameZoomInfo> LocalAdsMark::GetSymbolNames()
   return symbol;
 }
 
-df::RenderState::DepthLayer LocalAdsMark::GetDepthLayer() const
+df::DepthLayer LocalAdsMark::GetDepthLayer() const
 {
-  return df::RenderState::LocalAdsMarkLayer;
+  return df::DepthLayer::LocalAdsMarkLayer;
 }
 
 drape_ptr<df::UserPointMark::TitlesInfo> LocalAdsMark::GetTitleDecl() const
diff --git a/map/local_ads_mark.hpp b/map/local_ads_mark.hpp
index ecaf0b0f60..9739edefcf 100644
--- a/map/local_ads_mark.hpp
+++ b/map/local_ads_mark.hpp
@@ -19,10 +19,9 @@ struct LocalAdsMarkData
 class LocalAdsMark : public UserMark
 {
 public:
-  LocalAdsMark(m2::PointD const & ptOrg);
-  virtual ~LocalAdsMark() {}
+  explicit LocalAdsMark(m2::PointD const & ptOrg);
 
-  df::RenderState::DepthLayer GetDepthLayer() const override;
+  df::DepthLayer GetDepthLayer() const override;
 
   drape_ptr<SymbolNameZoomInfo> GetSymbolNames() const override;
 
diff --git a/map/routing_mark.cpp b/map/routing_mark.cpp
index 8a8fceefba..bbd38ba020 100644
--- a/map/routing_mark.cpp
+++ b/map/routing_mark.cpp
@@ -44,9 +44,9 @@ dp::Anchor RouteMarkPoint::GetAnchor() const
   return dp::Center;
 }
 
-df::RenderState::DepthLayer RouteMarkPoint::GetDepthLayer() const
+df::DepthLayer RouteMarkPoint::GetDepthLayer() const
 {
-  return df::RenderState::RoutingMarkLayer;
+  return df::DepthLayer::RoutingMarkLayer;
 }
 
 void RouteMarkPoint::SetRoutePointType(RouteMarkType type)
diff --git a/map/routing_mark.hpp b/map/routing_mark.hpp
index 35ae42dd02..d23dd2f9d2 100644
--- a/map/routing_mark.hpp
+++ b/map/routing_mark.hpp
@@ -34,7 +34,7 @@ public:
   void SetIsVisible(bool isVisible) { m_markData.m_isVisible = isVisible; }
 
   dp::Anchor GetAnchor() const override;
-  df::RenderState::DepthLayer GetDepthLayer() const override;
+  df::DepthLayer GetDepthLayer() const override;
 
   drape_ptr<SymbolNameZoomInfo> GetSymbolNames() const override;
   bool IsAvailableForSearch() const override { return !IsPassed(); }
@@ -105,10 +105,9 @@ private:
 class TransitMark : public UserMark
 {
 public:
-  TransitMark(m2::PointD const & ptOrg);
-  virtual ~TransitMark() {}
+  explicit TransitMark(m2::PointD const & ptOrg);
 
-  df::RenderState::DepthLayer GetDepthLayer() const override { return df::RenderState::TransitMarkLayer; }
+  df::DepthLayer GetDepthLayer() const override { return df::DepthLayer::TransitMarkLayer; }
 
   bool HasSymbolPriority() const override { return !m_symbolNames.empty() || !m_coloredSymbols.empty(); }
   bool HasTitlePriority() const override { return true; }
diff --git a/map/search_mark.cpp b/map/search_mark.cpp
index d3deb4f609..9e7f16800e 100644
--- a/map/search_mark.cpp
+++ b/map/search_mark.cpp
@@ -198,9 +198,9 @@ int SearchMarkPoint::GetMinTitleZoom() const
   return 1;
 }
 
-df::RenderState::DepthLayer SearchMarkPoint::GetDepthLayer() const
+df::DepthLayer SearchMarkPoint::GetDepthLayer() const
 {
-  return df::RenderState::SearchMarkLayer;
+  return df::DepthLayer::SearchMarkLayer;
 }
 
 void SearchMarkPoint::SetFoundFeature(FeatureID const & feature)
diff --git a/map/search_mark.hpp b/map/search_mark.hpp
index 8d28513630..f31f368b0e 100644
--- a/map/search_mark.hpp
+++ b/map/search_mark.hpp
@@ -39,7 +39,7 @@ public:
   df::ColorConstant GetColorConstant() const override;
   drape_ptr<TitlesInfo> GetTitleDecl() const override;
   int GetMinTitleZoom() const override;
-  df::RenderState::DepthLayer GetDepthLayer() const override;
+  df::DepthLayer GetDepthLayer() const override;
   drape_ptr<SymbolNameZoomInfo> GetBadgeNames() const override;
   drape_ptr<SymbolOffsets> GetSymbolOffsets() const override;
   bool GetDepthTestEnabled() const override { return false; }
diff --git a/map/track.cpp b/map/track.cpp
index 4e82b019dd..89e22471d0 100644
--- a/map/track.cpp
+++ b/map/track.cpp
@@ -46,9 +46,9 @@ double Track::GetLengthMeters() const
   return res;
 }
 
-df::RenderState::DepthLayer Track::GetDepthLayer() const
+df::DepthLayer Track::GetDepthLayer() const
 {
-  return df::RenderState::UserLineLayer;
+  return df::DepthLayer::UserLineLayer;
 }
 
 size_t Track::GetLayerCount() const
diff --git a/map/track.hpp b/map/track.hpp
index f4fcfd986d..f1953a2405 100644
--- a/map/track.hpp
+++ b/map/track.hpp
@@ -20,7 +20,7 @@ public:
   double GetLengthMeters() const;
 
   int GetMinZoom() const override { return 1; }
-  df::RenderState::DepthLayer GetDepthLayer() const override;
+  df::DepthLayer GetDepthLayer() const override;
   size_t GetLayerCount() const override;
   dp::Color GetColor(size_t layerIndex) const override;
   float GetWidth(size_t layerIndex) const override;
diff --git a/map/user_mark.cpp b/map/user_mark.cpp
index 60d97a8947..b47d5ccc3d 100644
--- a/map/user_mark.cpp
+++ b/map/user_mark.cpp
@@ -36,9 +36,9 @@ dp::Anchor UserMark::GetAnchor() const
   return dp::Center;
 }
 
-df::RenderState::DepthLayer UserMark::GetDepthLayer() const
+df::DepthLayer UserMark::GetDepthLayer() const
 {
-  return df::RenderState::UserMarkLayer;
+  return df::DepthLayer::UserMarkLayer;
 }
 
 ms::LatLon UserMark::GetLatLon() const
diff --git a/map/user_mark.hpp b/map/user_mark.hpp
index f4dced339f..bbd954a8cc 100644
--- a/map/user_mark.hpp
+++ b/map/user_mark.hpp
@@ -61,7 +61,7 @@ public:
   dp::Anchor GetAnchor() const override;
   bool GetDepthTestEnabled() const override { return true; }
   float GetDepth() const override { return 0.0f; }
-  df::RenderState::DepthLayer GetDepthLayer() const override;
+  df::DepthLayer GetDepthLayer() const override;
   drape_ptr<TitlesInfo> GetTitleDecl() const override { return nullptr; }
   drape_ptr<ColoredSymbolZoomInfo> GetColoredSymbols() const override { return nullptr; }
   drape_ptr<SymbolNameZoomInfo> GetBadgeNames() const override { return nullptr; }
diff --git a/xcode/drape/drape.xcodeproj/project.pbxproj b/xcode/drape/drape.xcodeproj/project.pbxproj
index 8a4d634632..4b9ce35e0b 100644
--- a/xcode/drape/drape.xcodeproj/project.pbxproj
+++ b/xcode/drape/drape.xcodeproj/project.pbxproj
@@ -20,6 +20,8 @@
 		457B536620358F7E00E4E752 /* drape_routine.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 457B536320358F7D00E4E752 /* drape_routine.hpp */; };
 		457B536720358F7E00E4E752 /* glyph_generator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 457B536420358F7D00E4E752 /* glyph_generator.cpp */; };
 		457B536820358F7E00E4E752 /* glyph_generator.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 457B536520358F7E00E4E752 /* glyph_generator.hpp */; };
+		45D7ADE22113535600160DE3 /* render_state.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 45D7ADE02113535500160DE3 /* render_state.hpp */; };
+		45D7ADE32113535600160DE3 /* render_state.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 45D7ADE12113535600160DE3 /* render_state.cpp */; };
 		670947231BDF9A4F005014C0 /* data_buffer_impl.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 670947151BDF9A4F005014C0 /* data_buffer_impl.hpp */; };
 		670947251BDF9A4F005014C0 /* bidi.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 670947171BDF9A4F005014C0 /* bidi.cpp */; };
 		670947261BDF9A4F005014C0 /* bidi.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 670947181BDF9A4F005014C0 /* bidi.hpp */; };
@@ -62,8 +64,6 @@
 		6729A57F1A69213A007D5872 /* glIncludes.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 6729A51B1A69213A007D5872 /* glIncludes.hpp */; };
 		6729A5801A69213A007D5872 /* glsl_func.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 6729A51C1A69213A007D5872 /* glsl_func.hpp */; };
 		6729A5811A69213A007D5872 /* glsl_types.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 6729A51D1A69213A007D5872 /* glsl_types.hpp */; };
-		6729A5821A69213A007D5872 /* glstate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6729A51E1A69213A007D5872 /* glstate.cpp */; };
-		6729A5831A69213A007D5872 /* glstate.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 6729A51F1A69213A007D5872 /* glstate.hpp */; };
 		6729A5861A69213A007D5872 /* gpu_buffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6729A5221A69213A007D5872 /* gpu_buffer.cpp */; };
 		6729A5871A69213A007D5872 /* gpu_buffer.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 6729A5231A69213A007D5872 /* gpu_buffer.hpp */; };
 		6729A58A1A69213A007D5872 /* gpu_program.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6729A5261A69213A007D5872 /* gpu_program.cpp */; };
@@ -127,6 +127,8 @@
 		457B536320358F7D00E4E752 /* drape_routine.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = drape_routine.hpp; sourceTree = "<group>"; };
 		457B536420358F7D00E4E752 /* glyph_generator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = glyph_generator.cpp; sourceTree = "<group>"; };
 		457B536520358F7E00E4E752 /* glyph_generator.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = glyph_generator.hpp; sourceTree = "<group>"; };
+		45D7ADE02113535500160DE3 /* render_state.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = render_state.hpp; sourceTree = "<group>"; };
+		45D7ADE12113535600160DE3 /* render_state.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = render_state.cpp; sourceTree = "<group>"; };
 		670947151BDF9A4F005014C0 /* data_buffer_impl.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = data_buffer_impl.hpp; sourceTree = "<group>"; };
 		670947171BDF9A4F005014C0 /* bidi.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bidi.cpp; sourceTree = "<group>"; };
 		670947181BDF9A4F005014C0 /* bidi.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = bidi.hpp; sourceTree = "<group>"; };
@@ -170,8 +172,6 @@
 		6729A51B1A69213A007D5872 /* glIncludes.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = glIncludes.hpp; sourceTree = "<group>"; };
 		6729A51C1A69213A007D5872 /* glsl_func.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = glsl_func.hpp; sourceTree = "<group>"; };
 		6729A51D1A69213A007D5872 /* glsl_types.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = glsl_types.hpp; sourceTree = "<group>"; };
-		6729A51E1A69213A007D5872 /* glstate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = glstate.cpp; sourceTree = "<group>"; };
-		6729A51F1A69213A007D5872 /* glstate.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = glstate.hpp; sourceTree = "<group>"; };
 		6729A5221A69213A007D5872 /* gpu_buffer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gpu_buffer.cpp; sourceTree = "<group>"; };
 		6729A5231A69213A007D5872 /* gpu_buffer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = gpu_buffer.hpp; sourceTree = "<group>"; };
 		6729A5261A69213A007D5872 /* gpu_program.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gpu_program.cpp; sourceTree = "<group>"; };
@@ -292,8 +292,6 @@
 				6729A51B1A69213A007D5872 /* glIncludes.hpp */,
 				6729A51C1A69213A007D5872 /* glsl_func.hpp */,
 				6729A51D1A69213A007D5872 /* glsl_types.hpp */,
-				6729A51E1A69213A007D5872 /* glstate.cpp */,
-				6729A51F1A69213A007D5872 /* glstate.hpp */,
 				457B536420358F7D00E4E752 /* glyph_generator.cpp */,
 				457B536520358F7E00E4E752 /* glyph_generator.hpp */,
 				670947191BDF9A4F005014C0 /* glyph_manager.cpp */,
@@ -302,9 +300,9 @@
 				6729A5231A69213A007D5872 /* gpu_buffer.hpp */,
 				6729A5261A69213A007D5872 /* gpu_program.cpp */,
 				6729A5271A69213A007D5872 /* gpu_program.hpp */,
-				BBB72E972111CE9100249D4F /* graphics_context.hpp */,
 				BBB72E992111CE9100249D4F /* graphics_context_factory.cpp */,
 				BBB72E982111CE9100249D4F /* graphics_context_factory.hpp */,
+				BBB72E972111CE9100249D4F /* graphics_context.hpp */,
 				6709471B1BDF9A4F005014C0 /* hw_texture_ios.hpp */,
 				6709471C1BDF9A4F005014C0 /* hw_texture_ios.mm */,
 				6709471D1BDF9A4F005014C0 /* hw_texture.cpp */,
@@ -316,8 +314,8 @@
 				6709471F1BDF9A4F005014C0 /* index_storage.cpp */,
 				670947201BDF9A4F005014C0 /* index_storage.hpp */,
 				6729A52C1A69213A007D5872 /* object_pool.hpp */,
-				6729A52D1A69213A007D5872 /* oglcontext.hpp */,
 				BBB72E8F2110AF0F00249D4F /* oglcontext.cpp */,
+				6729A52D1A69213A007D5872 /* oglcontext.hpp */,
 				6729A5301A69213A007D5872 /* overlay_handle.cpp */,
 				6729A5311A69213A007D5872 /* overlay_handle.hpp */,
 				6729A5321A69213A007D5872 /* overlay_tree.cpp */,
@@ -326,6 +324,8 @@
 				6729A5351A69213A007D5872 /* pointers.hpp */,
 				6729A5361A69213A007D5872 /* render_bucket.cpp */,
 				6729A5371A69213A007D5872 /* render_bucket.hpp */,
+				45D7ADE12113535600160DE3 /* render_state.cpp */,
+				45D7ADE02113535500160DE3 /* render_state.hpp */,
 				6729A53C1A69213A007D5872 /* shader.cpp */,
 				6729A53D1A69213A007D5872 /* shader.hpp */,
 				34C624C71DABDB2000510300 /* static_texture.cpp */,
@@ -388,6 +388,7 @@
 				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 */,
 				675D219A1BFB876E00717E4F /* projection.hpp in Headers */,
@@ -396,7 +397,6 @@
 				6729A5991A69213A007D5872 /* pointers.hpp in Headers */,
 				6729A5A51A69213A007D5872 /* symbols_texture.hpp in Headers */,
 				BBB72E9B2111CE9100249D4F /* graphics_context_factory.hpp in Headers */,
-				6729A5831A69213A007D5872 /* glstate.hpp in Headers */,
 				BBB72E9A2111CE9100249D4F /* graphics_context.hpp in Headers */,
 				6729A5741A69213A007D5872 /* data_buffer.hpp in Headers */,
 				6729A58B1A69213A007D5872 /* gpu_program.hpp in Headers */,
@@ -521,10 +521,10 @@
 				6729A5AA1A69213A007D5872 /* texture.cpp in Sources */,
 				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 */,
-				6729A5821A69213A007D5872 /* glstate.cpp in Sources */,
 				670947271BDF9A4F005014C0 /* glyph_manager.cpp in Sources */,
 				6729A56F1A69213A007D5872 /* color.cpp in Sources */,
 				6729A5671A69213A007D5872 /* batcher_helpers.cpp in Sources */,
diff --git a/xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj b/xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj
index d765365911..cf604bb14f 100644
--- a/xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj
+++ b/xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj
@@ -41,8 +41,6 @@
 		452FE5C41EB2004F00EE470C /* screen_quad_renderer.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 452FE5C21EB2004F00EE470C /* screen_quad_renderer.hpp */; };
 		453EEA6D1E3A28F400505E09 /* colored_symbol_shape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 453EEA6B1E3A28F400505E09 /* colored_symbol_shape.cpp */; };
 		453EEA6E1E3A28F400505E09 /* colored_symbol_shape.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 453EEA6C1E3A28F400505E09 /* colored_symbol_shape.hpp */; };
-		453FEDAC1F34C257005C1BB4 /* render_state.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 453FEDAA1F34C257005C1BB4 /* render_state.cpp */; };
-		453FEDAD1F34C257005C1BB4 /* render_state.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 453FEDAB1F34C257005C1BB4 /* render_state.hpp */; };
 		454B9A3A1F4591AD003FAE7A /* drape_engine_safe_ptr.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 454B9A391F4591AC003FAE7A /* drape_engine_safe_ptr.hpp */; };
 		454C19BB1CCE3EC0002A2C86 /* animation_constants.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 454C19B81CCE3EC0002A2C86 /* animation_constants.hpp */; };
 		454C19BC1CCE3EC0002A2C86 /* animation_system.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 454C19B91CCE3EC0002A2C86 /* animation_system.cpp */; };
@@ -61,6 +59,8 @@
 		45B4B8CD1CF5C16B00A54761 /* screen_operations.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 45B4B8C91CF5C16B00A54761 /* screen_operations.cpp */; };
 		45B4B8CE1CF5C16B00A54761 /* screen_operations.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 45B4B8CA1CF5C16B00A54761 /* screen_operations.hpp */; };
 		45BE604E20E504FC00A456AE /* frame_values.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 45BE604D20E504FC00A456AE /* frame_values.hpp */; };
+		45D7ADDE2113532700160DE3 /* render_state_extension.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 45D7ADDC2113532700160DE3 /* render_state_extension.hpp */; };
+		45D7ADDF2113532700160DE3 /* render_state_extension.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 45D7ADDD2113532700160DE3 /* render_state_extension.cpp */; };
 		45F1DA8420F3B274006E8CB3 /* drape_notifier.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 45F1DA8220F3B274006E8CB3 /* drape_notifier.hpp */; };
 		45F1DA8520F3B274006E8CB3 /* drape_notifier.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 45F1DA8320F3B274006E8CB3 /* drape_notifier.cpp */; };
 		56BF56DA1C7608C0006DD7CB /* choose_position_mark.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 56BF56D81C7608C0006DD7CB /* choose_position_mark.cpp */; };
@@ -250,8 +250,6 @@
 		453C5E8A2065599D00C78952 /* route_marker.fsh.glsl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = route_marker.fsh.glsl; path = shaders/route_marker.fsh.glsl; sourceTree = "<group>"; };
 		453EEA6B1E3A28F400505E09 /* colored_symbol_shape.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = colored_symbol_shape.cpp; sourceTree = "<group>"; };
 		453EEA6C1E3A28F400505E09 /* colored_symbol_shape.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = colored_symbol_shape.hpp; sourceTree = "<group>"; };
-		453FEDAA1F34C257005C1BB4 /* render_state.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = render_state.cpp; sourceTree = "<group>"; };
-		453FEDAB1F34C257005C1BB4 /* render_state.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = render_state.hpp; sourceTree = "<group>"; };
 		454B9A391F4591AC003FAE7A /* drape_engine_safe_ptr.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = drape_engine_safe_ptr.hpp; sourceTree = "<group>"; };
 		454C19B81CCE3EC0002A2C86 /* animation_constants.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = animation_constants.hpp; sourceTree = "<group>"; };
 		454C19B91CCE3EC0002A2C86 /* animation_system.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = animation_system.cpp; sourceTree = "<group>"; };
@@ -331,6 +329,8 @@
 		45BB02591EB8BE2B00FE5C0C /* user_mark_billboard.vsh.glsl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = user_mark_billboard.vsh.glsl; path = shaders/user_mark_billboard.vsh.glsl; sourceTree = "<group>"; };
 		45BB025A1EB8BE2B00FE5C0C /* user_mark.vsh.glsl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = user_mark.vsh.glsl; path = shaders/user_mark.vsh.glsl; sourceTree = "<group>"; };
 		45BE604D20E504FC00A456AE /* frame_values.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = frame_values.hpp; sourceTree = "<group>"; };
+		45D7ADDC2113532700160DE3 /* render_state_extension.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = render_state_extension.hpp; sourceTree = "<group>"; };
+		45D7ADDD2113532700160DE3 /* render_state_extension.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = render_state_extension.cpp; sourceTree = "<group>"; };
 		45F1DA8220F3B274006E8CB3 /* drape_notifier.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = drape_notifier.hpp; sourceTree = "<group>"; };
 		45F1DA8320F3B274006E8CB3 /* drape_notifier.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = drape_notifier.cpp; sourceTree = "<group>"; };
 		56BF56D81C7608C0006DD7CB /* choose_position_mark.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = choose_position_mark.cpp; sourceTree = "<group>"; };
@@ -678,8 +678,8 @@
 				670947641BDF9BE0005014C0 /* render_group.cpp */,
 				670947651BDF9BE0005014C0 /* render_group.hpp */,
 				670947671BDF9BE0005014C0 /* render_node.hpp */,
-				453FEDAA1F34C257005C1BB4 /* render_state.cpp */,
-				453FEDAB1F34C257005C1BB4 /* render_state.hpp */,
+				45D7ADDD2113532700160DE3 /* render_state_extension.cpp */,
+				45D7ADDC2113532700160DE3 /* render_state_extension.hpp */,
 				677A2DE31C0DD55D00635A00 /* requested_tiles.cpp */,
 				677A2DE41C0DD55D00635A00 /* requested_tiles.hpp */,
 				670947681BDF9BE0005014C0 /* route_builder.cpp */,
@@ -844,6 +844,7 @@
 				670E393D1C46C59000E9C0A6 /* color_constants.hpp in Headers */,
 				34C624C41DABDB0400510300 /* traffic_generator.hpp in Headers */,
 				347F520E1DC2334A0064B273 /* drape_api_builder.hpp in Headers */,
+				45D7ADDE2113532700160DE3 /* render_state_extension.hpp in Headers */,
 				6709484E1BDF9C48005014C0 /* shape.hpp in Headers */,
 				452C9EE31CEDCF3200A55E57 /* scale_animation.hpp in Headers */,
 				F6B283101C1B04680081957A /* gps_track_point.hpp in Headers */,
@@ -909,7 +910,6 @@
 				670947D71BDF9BE1005014C0 /* user_event_stream.hpp in Headers */,
 				6709479E1BDF9BE1005014C0 /* message_acceptor.hpp in Headers */,
 				6709484A1BDF9C48005014C0 /* ruler_helper.hpp in Headers */,
-				453FEDAD1F34C257005C1BB4 /* render_state.hpp in Headers */,
 				6743D36E1C3A9F090095054B /* arrow3d.hpp in Headers */,
 				670947B81BDF9BE1005014C0 /* route_builder.hpp in Headers */,
 				45BE604E20E504FC00A456AE /* frame_values.hpp in Headers */,
@@ -1006,6 +1006,7 @@
 				6709483B1BDF9C48005014C0 /* compass.cpp in Sources */,
 				453EEA6D1E3A28F400505E09 /* colored_symbol_shape.cpp in Sources */,
 				670947921BDF9BE1005014C0 /* kinetic_scroller.cpp in Sources */,
+				45D7ADDF2113532700160DE3 /* render_state_extension.cpp in Sources */,
 				6709484D1BDF9C48005014C0 /* shape.cpp in Sources */,
 				670948431BDF9C48005014C0 /* drape_gui.cpp in Sources */,
 				670947D61BDF9BE1005014C0 /* user_event_stream.cpp in Sources */,
@@ -1048,7 +1049,6 @@
 				670947B91BDF9BE1005014C0 /* route_renderer.cpp in Sources */,
 				670E393C1C46C59000E9C0A6 /* color_constants.cpp in Sources */,
 				677A2DE51C0DD55D00635A00 /* requested_tiles.cpp in Sources */,
-				453FEDAC1F34C257005C1BB4 /* render_state.cpp in Sources */,
 				45B4B8CD1CF5C16B00A54761 /* screen_operations.cpp in Sources */,
 				670947B31BDF9BE1005014C0 /* render_group.cpp in Sources */,
 				347F52111DC2334A0064B273 /* drape_api.cpp in Sources */,