Added supporting of 32-bit indices

37 files changed, 406 insertions, 255 deletions

diff --git a/drape/attribute_buffer_mutator.hpp b/drape/attribute_buffer_mutator.hpp
index 36235b9e79..b23ee8e68e 100644
--- a/drape/attribute_buffer_mutator.hpp
+++ b/drape/attribute_buffer_mutator.hpp
@@ -14,10 +14,10 @@ namespace dp
 struct MutateRegion
 {
   MutateRegion() : m_offset(0), m_count(0) {}
-  MutateRegion(uint16_t offset, uint16_t count) : m_offset(offset), m_count(count) {}
+  MutateRegion(uint32_t offset, uint32_t count) : m_offset(offset), m_count(count) {}
 
-  uint16_t m_offset; // Offset from buffer begin in "Elements" not in bytes
-  uint16_t m_count;  // Count of "Elements".
+  uint32_t m_offset; // Offset from buffer begin in "Elements" not in bytes
+  uint32_t m_count;  // Count of "Elements".
 };
 
 struct MutateNode
diff --git a/drape/attribute_provider.cpp b/drape/attribute_provider.cpp
index be6ec539ae..1271c8feb0 100644
--- a/drape/attribute_provider.cpp
+++ b/drape/attribute_provider.cpp
@@ -15,7 +15,7 @@
 namespace dp
 {
 
-AttributeProvider::AttributeProvider(uint8_t streamCount, uint16_t vertexCount)
+AttributeProvider::AttributeProvider(uint8_t streamCount, uint32_t vertexCount)
   : m_vertexCount(vertexCount)
 {
   m_streams.resize(streamCount);
@@ -29,7 +29,7 @@ bool AttributeProvider::IsDataExists() const
   return m_vertexCount > 0;
 }
 
-uint16_t AttributeProvider::GetVertexCount() const
+uint32_t AttributeProvider::GetVertexCount() const
 {
   return m_vertexCount;
 }
@@ -53,7 +53,7 @@ BindingInfo const & AttributeProvider::GetBindingInfo(uint8_t streamIndex) const
   return m_streams[streamIndex].m_binding;
 }
 
-void AttributeProvider::Advance(uint16_t vertexCount)
+void AttributeProvider::Advance(uint32_t vertexCount)
 {
   ASSERT_LESS_OR_EQUAL(vertexCount, m_vertexCount, ());
   CHECK_STREAMS;
diff --git a/drape/attribute_provider.hpp b/drape/attribute_provider.hpp
index ab6980d85c..05432e7484 100644
--- a/drape/attribute_provider.hpp
+++ b/drape/attribute_provider.hpp
@@ -11,17 +11,17 @@ namespace dp
 class AttributeProvider
 {
 public:
-  AttributeProvider(uint8_t streamCount, uint16_t vertexCount);
+  AttributeProvider(uint8_t streamCount, uint32_t vertexCount);
 
   /// interface for batcher
   bool IsDataExists() const;
-  uint16_t GetVertexCount() const;
+  uint32_t GetVertexCount() const;
 
   uint8_t GetStreamCount() const;
   void const * GetRawPointer(uint8_t streamIndex);
   BindingInfo const & GetBindingInfo(uint8_t streamIndex) const;
 
-  void Advance(uint16_t vertexCount);
+  void Advance(uint32_t vertexCount);
 
   void InitStream(uint8_t streamIndex,
                   BindingInfo const & bindingInfo,
diff --git a/drape/batcher.cpp b/drape/batcher.cpp
index 698939f233..0b45528e4d 100644
--- a/drape/batcher.cpp
+++ b/drape/batcher.cpp
@@ -1,6 +1,8 @@
 #include "drape/batcher.hpp"
-#include "drape/cpu_buffer.hpp"
 #include "drape/batcher_helpers.hpp"
+#include "drape/cpu_buffer.hpp"
+#include "drape/glextensions_list.hpp"
+#include "drape/index_storage.hpp"
 #include "drape/vertex_array_buffer.hpp"
 
 #include "base/assert.hpp"
@@ -32,23 +34,23 @@ public:
     m_indicesRange.m_idxStart = m_buffer->GetIndexCount();
   }
 
-  void FlushData(BindingInfo const & info, void const * data, uint16_t count)
+  void FlushData(BindingInfo const & info, void const * data, uint32_t count)
   {
     if (m_overlay != nullptr && info.IsDynamic())
     {
-      uint16_t offset = m_buffer->GetDynamicBufferOffset(info);
+      uint32_t offset = m_buffer->GetDynamicBufferOffset(info);
       m_overlay->AddDynamicAttribute(info, offset, count);
     }
     m_buffer->UploadData(info, data, count);
   }
 
-  uint16_t * GetIndexStorage(uint16_t size, uint16_t & startIndex)
+  void * GetIndexStorage(uint32_t size, uint32_t & startIndex)
   {
     startIndex = m_buffer->GetStartIndexValue();
     if (m_overlay == nullptr || !m_overlay->IndexesRequired())
     {
-      m_indexStorage.resize(size);
-      return &m_indexStorage[0];
+      m_indexStorage.Resize(size);
+      return m_indexStorage.GetRaw();
     }
     else
       return m_overlay->IndexStorage(size);
@@ -57,15 +59,15 @@ public:
   void SubmitIndexes()
   {
     if (m_overlay == nullptr || !m_overlay->IndexesRequired())
-      m_buffer->UploadIndexes(&m_indexStorage[0], m_indexStorage.size());
+      m_buffer->UploadIndexes(m_indexStorage.GetRawConst(), m_indexStorage.Size());
   }
 
-  uint16_t GetAvailableVertexCount() const
+  uint32_t GetAvailableVertexCount() const
   {
     return m_buffer->GetAvailableVertexCount();
   }
 
-  uint16_t GetAvailableIndexCount() const
+  uint32_t GetAvailableIndexCount() const
   {
     return m_buffer->GetAvailableIndexCount();
   }
@@ -89,7 +91,7 @@ private:
   GLState const & m_state;
   ref_ptr<VertexArrayBuffer> m_buffer;
   ref_ptr<OverlayHandle> m_overlay;
-  vector<uint16_t> m_indexStorage;
+  IndexStorage m_indexStorage;
   IndicesRange m_indicesRange;
   bool m_vaoChanged;
 };
@@ -245,6 +247,19 @@ IndicesRange Batcher::InsertTriangles(GLState const & state, ref_ptr<AttributePr
   return range;
 }
 
+Batcher * BatcherFactory::GetNew() const
+{
+  uint32_t indexBufferSize = 65000;
+  uint32_t vertexBufferSize = 65000;
+  if (GLExtensionsList::Instance().IsSupported(GLExtensionsList::UintIndices))
+  {
+    indexBufferSize = 65000 * 2;
+    vertexBufferSize = 65000 * 2;
+  }
+
+  return new Batcher(indexBufferSize, vertexBufferSize);
+}
+
 SessionGuard::SessionGuard(Batcher & batcher, const Batcher::TFlushFn & flusher)
   : m_batcher(batcher)
 {
diff --git a/drape/batcher.hpp b/drape/batcher.hpp
index 42cedbeaae..d4d6ca2456 100644
--- a/drape/batcher.hpp
+++ b/drape/batcher.hpp
@@ -26,7 +26,7 @@ public:
   static uint32_t const IndexPerQuad = 6;
   static uint32_t const VertexPerQuad = 4;
 
-  Batcher(uint32_t indexBufferSize = 65000, uint32_t vertexBufferSize = 65000);
+  Batcher(uint32_t indexBufferSize, uint32_t vertexBufferSize);
   ~Batcher();
 
   uint32_t GetIndexBufferSize() const { return m_indexBufferSize; }
@@ -80,7 +80,7 @@ private:
 class BatcherFactory
 {
 public:
-  Batcher * GetNew() const { return new Batcher(); }
+  Batcher * GetNew() const;
 };
 
 class SessionGuard
diff --git a/drape/batcher_helpers.cpp b/drape/batcher_helpers.cpp
index da650051a9..c3c3d1392d 100644
--- a/drape/batcher_helpers.cpp
+++ b/drape/batcher_helpers.cpp
@@ -1,6 +1,7 @@
 #include "drape/batcher_helpers.hpp"
 #include "drape/attribute_provider.hpp"
 #include "drape/cpu_buffer.hpp"
+#include "drape/glextensions_list.hpp"
 
 #include "base/assert.hpp"
 #include "base/math.hpp"
@@ -13,28 +14,53 @@ namespace dp
 namespace
 {
 
-bool IsEnoughMemory(uint16_t avVertex, uint16_t existVertex, uint16_t avIndex, uint16_t existIndex)
+bool IsEnoughMemory(uint32_t avVertex, uint32_t existVertex, uint32_t avIndex, uint32_t existIndex)
 {
   return avVertex >= existVertex && avIndex >= existIndex;
 }
 
+bool IsSupported32bit()
+{
+  static bool const supports32bit = GLExtensionsList::Instance().IsSupported(GLExtensionsList::UintIndices);
+  return supports32bit;
+}
+
+template<typename TGenerator> void GenerateIndices(void * indexStorage, uint32_t count, uint32_t startIndex)
+{
+  GenerateIndices<TGenerator>(indexStorage, count, TGenerator(startIndex));
+}
+
+template<typename TGenerator> void GenerateIndices(void * indexStorage, uint32_t count, TGenerator const & generator)
+{
+  if (IsSupported32bit())
+  {
+    uint32_t * pIndexStorage = static_cast<uint32_t *>(indexStorage);
+    generate(pIndexStorage, pIndexStorage + count, generator);
+  }
+  else
+  {
+    uint16_t * pIndexStorage = static_cast<uint16_t *>(indexStorage);
+    generate(pIndexStorage, pIndexStorage + count, generator);
+  }
+}
+
 class IndexGenerator
 {
 public:
-  IndexGenerator(uint16_t startIndex)
+  IndexGenerator(uint32_t startIndex)
     : m_startIndex(startIndex)
     , m_counter(0)
     , m_minStriptCounter(0) {}
 
 protected:
-  uint16_t GetCounter() { return m_counter++; }
+  uint32_t GetCounter() { return m_counter++; }
   void ResetCounter()
   {
     m_counter = 0;
     m_minStriptCounter = 0;
   }
 
-  uint16_t const m_startIndex;
+  uint32_t const m_startIndex;
 
   int16_t GetCWNormalizer()
   {
@@ -49,40 +75,40 @@ protected:
   }
 
 private:
-  uint16_t m_counter;
+  uint32_t m_counter;
   uint8_t m_minStriptCounter;
 };
 
 class ListIndexGenerator : public IndexGenerator
 {
 public:
-  ListIndexGenerator(uint16_t startIndex) : IndexGenerator(startIndex) {}
-  uint16_t operator()() { return m_startIndex + GetCounter(); }
+  ListIndexGenerator(uint32_t startIndex) : IndexGenerator(startIndex) {}
+  uint32_t operator()() { return m_startIndex + GetCounter(); }
 };
 
 class StripIndexGenerator : public IndexGenerator
 {
 public:
-  StripIndexGenerator(uint16_t startIndex)
+  StripIndexGenerator(uint32_t startIndex)
     : IndexGenerator(startIndex)
     , m_minStriptCounter(0) {}
-  uint16_t operator()()
+  uint32_t operator()()
   {
-    uint16_t const counter = GetCounter();
+    uint32_t const counter = GetCounter();
     return m_startIndex + counter - 2 * (counter / 3) + GetCWNormalizer();
   }
 
 private:
-  uint16_t m_minStriptCounter;
+  uint32_t m_minStriptCounter;
 };
 
 class FanIndexGenerator : public IndexGenerator
 {
 public:
-  FanIndexGenerator(uint16_t startIndex) : IndexGenerator(startIndex) {}
-  uint16_t operator()()
+  FanIndexGenerator(uint32_t startIndex) : IndexGenerator(startIndex) {}
+  uint32_t operator()()
   {
-    uint16_t const counter = GetCounter();
+    uint32_t const counter = GetCounter();
     if ((counter % 3) == 0)
       return m_startIndex;
     return m_startIndex + counter - 2 * (counter / 3);
@@ -92,16 +118,16 @@ public:
 class ListOfStriptGenerator : public IndexGenerator
 {
 public:
-  ListOfStriptGenerator(uint16_t startIndex, uint16_t vertexStride, uint16_t indexPerStrip)
+  ListOfStriptGenerator(uint32_t startIndex, uint32_t vertexStride, uint32_t indexPerStrip)
     : IndexGenerator(startIndex)
     , m_vertexStride(vertexStride)
     , m_indexPerStrip(indexPerStrip)
     , m_base(0) {}
 
-  uint16_t operator()()
+  uint32_t operator()()
   {
-    uint16_t const counter = GetCounter();
-    uint16_t const result = m_startIndex + m_base + counter - 2 * (counter / 3) + GetCWNormalizer();
+    uint32_t const counter = GetCounter();
+    uint32_t const result = m_startIndex + m_base + counter - 2 * (counter / 3) + GetCWNormalizer();
     if (counter + 1 == m_indexPerStrip)
     {
       m_base += m_vertexStride;
@@ -112,9 +138,9 @@ public:
   }
 
 private:
-  uint16_t m_vertexStride;
-  uint16_t m_indexPerStrip;
-  uint16_t m_base;
+  uint32_t m_vertexStride;
+  uint32_t m_indexPerStrip;
+  uint32_t m_base;
 };
 
 } // namespace
@@ -140,19 +166,19 @@ void TriangleBatch::SetVertexStride(uint8_t vertexStride)
   m_vertexStride = vertexStride;
 }
 
-void TriangleBatch::FlushData(ref_ptr<AttributeProvider> streams, uint16_t vertexVount) const
+void TriangleBatch::FlushData(ref_ptr<AttributeProvider> streams, uint32_t vertexVount) const
 {
   for (uint8_t i = 0; i < streams->GetStreamCount(); ++i)
     FlushData(streams->GetBindingInfo(i), streams->GetRawPointer(i), vertexVount);
 }
 
-void TriangleBatch::FlushData(BindingInfo const & info, void const * data, uint16_t elementCount) const
+void TriangleBatch::FlushData(BindingInfo const & info, void const * data, uint32_t elementCount) const
 {
   ASSERT(m_callbacks.m_flushVertex != NULL, ());
   return m_callbacks.m_flushVertex(info, data, elementCount);
 }
 
-uint16_t * TriangleBatch::GetIndexStorage(uint16_t indexCount, uint16_t & startIndex)
+void * TriangleBatch::GetIndexStorage(uint32_t indexCount, uint32_t & startIndex)
 {
   ASSERT(m_callbacks.m_getIndexStorage, ());
   return m_callbacks.m_getIndexStorage(indexCount, startIndex);
@@ -164,13 +190,13 @@ void TriangleBatch::SubmitIndex()
   m_callbacks.m_submitIndex();
 }
 
-uint16_t TriangleBatch::GetAvailableVertexCount() const
+uint32_t TriangleBatch::GetAvailableVertexCount() const
 {
   ASSERT(m_callbacks.m_getAvailableVertex!= NULL, ());
   return m_callbacks.m_getAvailableVertex();
 }
 
-uint16_t TriangleBatch::GetAvailableIndexCount() const
+uint32_t TriangleBatch::GetAvailableIndexCount() const
 {
   ASSERT(m_callbacks.m_getAvailableIndex != NULL, ());
   return m_callbacks.m_getAvailableIndex();
@@ -187,7 +213,7 @@ uint8_t TriangleBatch::GetVertexStride() const
   return m_vertexStride;
 }
 
-bool TriangleBatch::IsBufferFilled(uint16_t availableVerticesCount, uint16_t availableIndicesCount) const
+bool TriangleBatch::IsBufferFilled(uint32_t availableVerticesCount, uint32_t availableIndicesCount) const
 {
   return availableVerticesCount < 3 || availableIndicesCount < 3;
 }
@@ -201,9 +227,9 @@ void TriangleListBatch::BatchData(ref_ptr<AttributeProvider> streams)
     if (IsBufferFilled(GetAvailableVertexCount(), GetAvailableIndexCount()))
       ChangeBuffer();
 
-    uint16_t avVertex = GetAvailableVertexCount();
-    uint16_t avIndex  = GetAvailableIndexCount();
-    uint16_t vertexCount = streams->GetVertexCount();
+    uint32_t avVertex = GetAvailableVertexCount();
+    uint32_t avIndex  = GetAvailableIndexCount();
+    uint32_t vertexCount = streams->GetVertexCount();
 
     if (IsCanDevideStreams())
     {
@@ -221,9 +247,9 @@ void TriangleListBatch::BatchData(ref_ptr<AttributeProvider> streams)
       ASSERT(vertexCount % 3 == 0, ());
     }
 
-    uint16_t startIndex = 0;
-    uint16_t * pIndexStorage = GetIndexStorage(vertexCount, startIndex);
-    generate(pIndexStorage, pIndexStorage + vertexCount, ListIndexGenerator(startIndex));
+    uint32_t startIndex = 0;
+    void * indicesStorage = GetIndexStorage(vertexCount, startIndex);
+    GenerateIndices<ListIndexGenerator>(indicesStorage, vertexCount, startIndex);
     SubmitIndex();
 
     FlushData(streams, vertexCount);
@@ -237,13 +263,13 @@ FanStripHelper::FanStripHelper(BatchCallbacks const & callbacks)
 {
 }
 
-uint16_t FanStripHelper::BatchIndexes(uint16_t vertexCount)
+uint32_t FanStripHelper::BatchIndexes(uint32_t vertexCount)
 {
-  uint16_t avVertex = GetAvailableVertexCount();
-  uint16_t avIndex  = GetAvailableIndexCount();
+  uint32_t avVertex = GetAvailableVertexCount();
+  uint32_t avIndex  = GetAvailableIndexCount();
 
-  uint16_t batchVertexCount = 0;
-  uint16_t batchIndexCount = 0;
+  uint32_t batchVertexCount = 0;
+  uint32_t batchIndexCount = 0;
   CalcBatchPortion(vertexCount, avVertex, avIndex, batchVertexCount, batchIndexCount);
 
   if (!IsFullUploaded() && !IsCanDevideStreams())
@@ -255,26 +281,26 @@ uint16_t FanStripHelper::BatchIndexes(uint16_t vertexCount)
     ASSERT(IsFullUploaded(), ());
   }
 
-  uint16_t startIndex = 0;
-  uint16_t * pIndexStorage = GetIndexStorage(batchIndexCount, startIndex);
+  uint32_t startIndex = 0;
+  void * pIndexStorage = GetIndexStorage(batchIndexCount, startIndex);
   GenerateIndexes(pIndexStorage, batchIndexCount, startIndex);
   SubmitIndex();
 
   return batchVertexCount;
 }
 
-void FanStripHelper::CalcBatchPortion(uint16_t vertexCount, uint16_t avVertex, uint16_t avIndex,
-                                      uint16_t & batchVertexCount, uint16_t & batchIndexCount)
+void FanStripHelper::CalcBatchPortion(uint32_t vertexCount, uint32_t avVertex, uint32_t avIndex,
+                                      uint32_t & batchVertexCount, uint32_t & batchIndexCount)
 {
-  uint16_t const indexCount = VtoICount(vertexCount);
+  uint32_t const indexCount = VtoICount(vertexCount);
   batchVertexCount = vertexCount;
   batchIndexCount = indexCount;
   m_isFullUploaded = true;
 
   if (vertexCount > avVertex || indexCount > avIndex)
   {
-    uint16_t alignedAvVertex = AlignVCount(avVertex);
-    uint16_t alignedAvIndex = AlignICount(avIndex);
+    uint32_t alignedAvVertex = AlignVCount(avVertex);
+    uint32_t alignedAvIndex = AlignICount(avIndex);
     uint32_t indexCountForAvailableVertexCount = VtoICount(alignedAvVertex);
     if (indexCountForAvailableVertexCount <= alignedAvIndex)
     {
@@ -295,22 +321,22 @@ bool FanStripHelper::IsFullUploaded() const
   return m_isFullUploaded;
 }
 
-uint16_t FanStripHelper::VtoICount(uint16_t vCount) const
+uint32_t FanStripHelper::VtoICount(uint32_t vCount) const
 {
   return 3 * (vCount - 2);
 }
 
-uint16_t FanStripHelper::ItoVCount(uint16_t iCount) const
+uint32_t FanStripHelper::ItoVCount(uint32_t iCount) const
 {
   return iCount / 3 + 2;
 }
 
-uint16_t FanStripHelper::AlignVCount(uint16_t vCount) const
+uint32_t FanStripHelper::AlignVCount(uint32_t vCount) const
 {
   return vCount;
 }
 
-uint16_t FanStripHelper::AlignICount(uint16_t iCount) const
+uint32_t FanStripHelper::AlignICount(uint32_t iCount) const
 {
   return iCount - iCount % 3;
 }
@@ -327,18 +353,18 @@ void TriangleStripBatch::BatchData(ref_ptr<AttributeProvider> streams)
     if (IsBufferFilled(GetAvailableVertexCount(), GetAvailableIndexCount()))
       ChangeBuffer();
 
-    uint16_t const batchVertexCount = BatchIndexes(streams->GetVertexCount());
+    uint32_t const batchVertexCount = BatchIndexes(streams->GetVertexCount());
     FlushData(streams, batchVertexCount);
 
-    uint16_t const advanceCount = IsFullUploaded() ? batchVertexCount : (batchVertexCount - 2);
+    uint32_t const advanceCount = IsFullUploaded() ? batchVertexCount : (batchVertexCount - 2);
     streams->Advance(advanceCount);
 
   }
 }
 
-void TriangleStripBatch::GenerateIndexes(uint16_t * indexStorage, uint16_t count, uint16_t startIndex) const
+void TriangleStripBatch::GenerateIndexes(void * indexStorage, uint32_t count, uint32_t startIndex) const
 {
-  generate(indexStorage, indexStorage + count, StripIndexGenerator(startIndex));
+  GenerateIndices<StripIndexGenerator>(indexStorage, count, startIndex);
 }
 
 TriangleFanBatch::TriangleFanBatch(BatchCallbacks const & callbacks) : TBase(callbacks) {}
@@ -370,8 +396,8 @@ void TriangleFanBatch::BatchData(ref_ptr<AttributeProvider> streams)
     if (IsBufferFilled(GetAvailableVertexCount(), GetAvailableIndexCount()))
       ChangeBuffer();
 
-    uint16_t vertexCount = streams->GetVertexCount();
-    uint16_t batchVertexCount = BatchIndexes(vertexCount);
+    uint32_t vertexCount = streams->GetVertexCount();
+    uint32_t batchVertexCount = BatchIndexes(vertexCount);
 
     if (!cpuBuffers.empty())
     {
@@ -397,7 +423,7 @@ void TriangleFanBatch::BatchData(ref_ptr<AttributeProvider> streams)
         cpuBuffer.Seek(1);
       }
 
-      uint16_t advanceCount = batchVertexCount;
+      uint32_t advanceCount = batchVertexCount;
       if (!IsFullUploaded())
       {
         // not all data was moved on gpu and last vertex of fan
@@ -443,9 +469,9 @@ void TriangleFanBatch::BatchData(ref_ptr<AttributeProvider> streams)
   }
 }
 
-void TriangleFanBatch::GenerateIndexes(uint16_t * indexStorage, uint16_t count, uint16_t startIndex) const
+void TriangleFanBatch::GenerateIndexes(void * indexStorage, uint32_t count, uint32_t startIndex) const
 {
-  generate(indexStorage, indexStorage + count, FanIndexGenerator(startIndex));
+  GenerateIndices<FanIndexGenerator>(indexStorage, count, startIndex);
 }
 
 TriangleListOfStripBatch::TriangleListOfStripBatch(BatchCallbacks const & callbacks)
@@ -460,32 +486,32 @@ void TriangleListOfStripBatch::BatchData(ref_ptr<AttributeProvider> streams)
     if (IsBufferFilled(GetAvailableVertexCount(), GetAvailableIndexCount()))
       ChangeBuffer();
 
-    uint16_t const batchVertexCount = BatchIndexes(streams->GetVertexCount());
+    uint32_t const batchVertexCount = BatchIndexes(streams->GetVertexCount());
     FlushData(streams, batchVertexCount);
     streams->Advance(batchVertexCount);
   }
 }
 
-bool TriangleListOfStripBatch::IsBufferFilled(uint16_t availableVerticesCount, uint16_t availableIndicesCount) const
+bool TriangleListOfStripBatch::IsBufferFilled(uint32_t availableVerticesCount, uint32_t availableIndicesCount) const
 {
   uint8_t const vertexStride = GetVertexStride();
   ASSERT_GREATER_OR_EQUAL(vertexStride, 4, ());
 
-  uint16_t const indicesPerStride = TBase::VtoICount(vertexStride);
+  uint32_t const indicesPerStride = TBase::VtoICount(vertexStride);
   return availableVerticesCount < vertexStride || availableIndicesCount < indicesPerStride;
 }
 
-uint16_t TriangleListOfStripBatch::VtoICount(uint16_t vCount) const
+uint32_t TriangleListOfStripBatch::VtoICount(uint32_t vCount) const
 {
   uint8_t const vertexStride = GetVertexStride();
   ASSERT_GREATER_OR_EQUAL(vertexStride, 4, ());
   ASSERT_EQUAL(vCount % vertexStride, 0, ());
 
-  uint16_t const striptCount = vCount / vertexStride;
+  uint32_t const striptCount = vCount / vertexStride;
   return striptCount * TBase::VtoICount(vertexStride);
 }
 
-uint16_t TriangleListOfStripBatch::ItoVCount(uint16_t iCount) const
+uint32_t TriangleListOfStripBatch::ItoVCount(uint32_t iCount) const
 {
   uint8_t const vertexStride = GetVertexStride();
   ASSERT_GREATER_OR_EQUAL(vertexStride, 4, ());
@@ -494,24 +520,24 @@ uint16_t TriangleListOfStripBatch::ItoVCount(uint16_t iCount) const
   return vertexStride * iCount / TBase::VtoICount(vertexStride);
 }
 
-uint16_t TriangleListOfStripBatch::AlignVCount(uint16_t vCount) const
+uint32_t TriangleListOfStripBatch::AlignVCount(uint32_t vCount) const
 {
   return vCount - vCount % GetVertexStride();
 }
 
-uint16_t TriangleListOfStripBatch::AlignICount(uint16_t iCount) const
+uint32_t TriangleListOfStripBatch::AlignICount(uint32_t iCount) const
 {
   uint8_t const vertexStride = GetVertexStride();
   ASSERT_GREATER_OR_EQUAL(vertexStride, 4, ());
 
-  uint16_t const indicesPerStride = TBase::VtoICount(vertexStride);
+  uint32_t const indicesPerStride = TBase::VtoICount(vertexStride);
   return iCount - iCount % indicesPerStride;
 }
 
-void TriangleListOfStripBatch::GenerateIndexes(uint16_t * indexStorage, uint16_t count, uint16_t startIndex) const
+void TriangleListOfStripBatch::GenerateIndexes(void * indexStorage, uint32_t count, uint32_t startIndex) const
 {
   uint8_t const vertexStride = GetVertexStride();
-  generate(indexStorage, indexStorage + count, ListOfStriptGenerator(startIndex, vertexStride, VtoICount(vertexStride)));
+  GenerateIndices(indexStorage, count, ListOfStriptGenerator(startIndex, vertexStride, VtoICount(vertexStride)));
 }
 
 } // namespace dp
diff --git a/drape/batcher_helpers.hpp b/drape/batcher_helpers.hpp
index 60fd878b52..b9214001e0 100644
--- a/drape/batcher_helpers.hpp
+++ b/drape/batcher_helpers.hpp
@@ -13,10 +13,10 @@ class BindingInfo;
 class BatchCallbacks
 {
 public:
-  typedef function<void (BindingInfo const &, void const *, uint16_t)> TFlushVertexFn;
-  typedef function<uint16_t * (uint16_t, uint16_t &)> TGetIndexStorageFn;
+  typedef function<void (BindingInfo const &, void const *, uint32_t)> TFlushVertexFn;
+  typedef function<void * (uint32_t, uint32_t &)> TGetIndexStorageFn;
   typedef function<void ()> TSubmitIndexFn;
-  typedef function<uint16_t ()> TGetAvailableFn;
+  typedef function<uint32_t ()> TGetAvailableFn;
   typedef function<void ()> ChangeBufferFn;
 
   TFlushVertexFn      m_flushVertex;
@@ -39,16 +39,16 @@ public:
   void SetVertexStride(uint8_t vertexStride);
 
 protected:
-  void FlushData(ref_ptr<AttributeProvider> streams, uint16_t vertexVount) const;
-  void FlushData(BindingInfo const & info, void const * data, uint16_t elementCount) const;
-  uint16_t * GetIndexStorage(uint16_t indexCount, uint16_t & startIndex);
+  void FlushData(ref_ptr<AttributeProvider> streams, uint32_t vertexVount) const;
+  void FlushData(BindingInfo const & info, void const * data, uint32_t elementCount) const;
+  void * GetIndexStorage(uint32_t indexCount, uint32_t & startIndex);
   void SubmitIndex();
-  uint16_t GetAvailableVertexCount() const;
-  uint16_t GetAvailableIndexCount() const;
+  uint32_t GetAvailableVertexCount() const;
+  uint32_t GetAvailableIndexCount() const;
   void ChangeBuffer() const;
   uint8_t GetVertexStride() const;
 
-  virtual bool IsBufferFilled(uint16_t availableVerticesCount, uint16_t availableIndicesCount) const;
+  virtual bool IsBufferFilled(uint32_t availableVerticesCount, uint32_t availableIndicesCount) const;
 
 private:
   BatchCallbacks m_callbacks;
@@ -74,16 +74,16 @@ public:
   FanStripHelper(BatchCallbacks const & callbacks);
 
 protected:
-  uint16_t BatchIndexes(uint16_t vertexCount);
-  void CalcBatchPortion(uint16_t vertexCount, uint16_t avVertex, uint16_t avIndex,
-                        uint16_t & batchVertexCount, uint16_t & batchIndexCount);
+  uint32_t BatchIndexes(uint32_t vertexCount);
+  void CalcBatchPortion(uint32_t vertexCount, uint32_t avVertex, uint32_t avIndex,
+                        uint32_t & batchVertexCount, uint32_t & batchIndexCount);
   bool IsFullUploaded() const;
 
-  virtual uint16_t VtoICount(uint16_t vCount) const;
-  virtual uint16_t ItoVCount(uint16_t iCount) const;
-  virtual uint16_t AlignVCount(uint16_t vCount) const;
-  virtual uint16_t AlignICount(uint16_t vCount) const;
-  virtual void GenerateIndexes(uint16_t * indexStorage, uint16_t count, uint16_t startIndex) const = 0;
+  virtual uint32_t VtoICount(uint32_t vCount) const;
+  virtual uint32_t ItoVCount(uint32_t iCount) const;
+  virtual uint32_t AlignVCount(uint32_t vCount) const;
+  virtual uint32_t AlignICount(uint32_t vCount) const;
+  virtual void GenerateIndexes(void * indexStorage, uint32_t count, uint32_t startIndex) const = 0;
 
 private:
   bool m_isFullUploaded;
@@ -98,7 +98,7 @@ public:
 
   virtual void BatchData(ref_ptr<AttributeProvider> streams);
 protected:
-  virtual void GenerateIndexes(uint16_t * indexStorage, uint16_t count, uint16_t startIndex) const;
+  virtual void GenerateIndexes(void * indexStorage, uint32_t count, uint32_t startIndex) const;
 };
 
 class TriangleFanBatch : public FanStripHelper
@@ -110,7 +110,7 @@ public:
 
   virtual void BatchData(ref_ptr<AttributeProvider> streams);
 protected:
-  virtual void GenerateIndexes(uint16_t * indexStorage, uint16_t count, uint16_t startIndex) const;
+  virtual void GenerateIndexes(void * indexStorage, uint32_t count, uint32_t startIndex) const;
 };
 
 class TriangleListOfStripBatch : public FanStripHelper
@@ -123,12 +123,12 @@ public:
   virtual void BatchData(ref_ptr<AttributeProvider> streams);
 
 protected:
-  virtual bool IsBufferFilled(uint16_t availableVerticesCount, uint16_t availableIndicesCount) const;
-  virtual uint16_t VtoICount(uint16_t vCount) const;
-  virtual uint16_t ItoVCount(uint16_t iCount) const;
-  virtual uint16_t AlignVCount(uint16_t vCount) const;
-  virtual uint16_t AlignICount(uint16_t iCount) const;
-  virtual void GenerateIndexes(uint16_t * indexStorage, uint16_t count, uint16_t startIndex) const;
+  virtual bool IsBufferFilled(uint32_t availableVerticesCount, uint32_t availableIndicesCount) const;
+  virtual uint32_t VtoICount(uint32_t vCount) const;
+  virtual uint32_t ItoVCount(uint32_t iCount) const;
+  virtual uint32_t AlignVCount(uint32_t vCount) const;
+  virtual uint32_t AlignICount(uint32_t iCount) const;
+  virtual void GenerateIndexes(void * indexStorage, uint32_t count, uint32_t startIndex) const;
 };
 
 } // namespace dp
diff --git a/drape/buffer_base.cpp b/drape/buffer_base.cpp
index a8b6d9dd9e..99170b9a83 100644
--- a/drape/buffer_base.cpp
+++ b/drape/buffer_base.cpp
@@ -4,29 +4,29 @@
 namespace dp
 {
 
-BufferBase::BufferBase(uint8_t elementSize, uint16_t capacity)
+BufferBase::BufferBase(uint8_t elementSize, uint32_t capacity)
   : m_elementSize(elementSize)
   , m_capacity(capacity)
   , m_size(0)
 {
 }
 
-uint16_t BufferBase::GetCapacity() const
+uint32_t BufferBase::GetCapacity() const
 {
   return m_capacity;
 }
 
-uint16_t BufferBase::GetCurrentSize() const
+uint32_t BufferBase::GetCurrentSize() const
 {
   return m_size;
 }
 
-uint16_t BufferBase::GetAvailableSize() const
+uint32_t BufferBase::GetAvailableSize() const
 {
   return m_capacity - m_size;
 }
 
-void BufferBase::Resize(uint16_t elementCount)
+void BufferBase::Resize(uint32_t elementCount)
 {
   m_capacity = elementCount;
   m_size = 0;
@@ -37,19 +37,19 @@ uint8_t BufferBase::GetElementSize() const
   return m_elementSize;
 }
 
-void BufferBase::Seek(uint16_t elementNumber)
+void BufferBase::Seek(uint32_t elementNumber)
 {
   ASSERT(elementNumber <= m_capacity, ());
   m_size = elementNumber;
 }
 
-void BufferBase::UploadData(uint16_t elementCount)
+void BufferBase::UploadData(uint32_t elementCount)
 {
   ASSERT(m_size + elementCount <= m_capacity, ());
   m_size += elementCount;
 }
 
-void BufferBase::SetDataSize(uint16_t elementCount)
+void BufferBase::SetDataSize(uint32_t elementCount)
 {
   ASSERT(elementCount <= m_capacity, ());
   m_size = elementCount;
diff --git a/drape/buffer_base.hpp b/drape/buffer_base.hpp
index 4ff6551407..78b0ee4194 100644
--- a/drape/buffer_base.hpp
+++ b/drape/buffer_base.hpp
@@ -8,25 +8,25 @@ namespace dp
 class BufferBase
 {
 public:
-  BufferBase(uint8_t elementSize, uint16_t capacity);
+  BufferBase(uint8_t elementSize, uint32_t capacity);
 
-  uint16_t GetCapacity() const;
-  uint16_t GetCurrentSize() const;
-  uint16_t GetAvailableSize() const;
+  uint32_t GetCapacity() const;
+  uint32_t GetCurrentSize() const;
+  uint32_t GetAvailableSize() const;
 
   uint8_t GetElementSize() const;
 
-  void Seek(uint16_t elementNumber);
+  void Seek(uint32_t elementNumber);
 
 protected:
-  void Resize(uint16_t elementCount);
-  void UploadData(uint16_t elementCount);
-  void SetDataSize(uint16_t elementCount);
+  void Resize(uint32_t elementCount);
+  void UploadData(uint32_t elementCount);
+  void SetDataSize(uint32_t elementCount);
 
 private:
   uint8_t m_elementSize;
-  uint16_t m_capacity;
-  uint16_t m_size;
+  uint32_t m_capacity;
+  uint32_t m_size;
 };
 
 } // namespace dp
diff --git a/drape/cpu_buffer.cpp b/drape/cpu_buffer.cpp
index fbd6b83321..7aa72ef528 100644
--- a/drape/cpu_buffer.cpp
+++ b/drape/cpu_buffer.cpp
@@ -9,7 +9,7 @@
 namespace dp
 {
 
-CPUBuffer::CPUBuffer(uint8_t elementSize, uint16_t capacity)
+CPUBuffer::CPUBuffer(uint8_t elementSize, uint32_t capacity)
   : TBase(elementSize, capacity)
 {
   uint32_t memorySize = my::NextPowOf2(GetCapacity() * GetElementSize());
@@ -23,7 +23,7 @@ CPUBuffer::~CPUBuffer()
   SharedBufferManager::instance().freeSharedBuffer(m_memory->size(), m_memory);
 }
 
-void CPUBuffer::UploadData(void const * data, uint16_t elementCount)
+void CPUBuffer::UploadData(void const * data, uint32_t elementCount)
 {
   uint32_t byteCountToCopy = GetElementSize() * elementCount;
 #ifdef DEBUG
@@ -35,7 +35,7 @@ void CPUBuffer::UploadData(void const * data, uint16_t elementCount)
   TBase::UploadData(elementCount);
 }
 
-void CPUBuffer::Seek(uint16_t elementNumber)
+void CPUBuffer::Seek(uint32_t elementNumber)
 {
   uint32_t offsetFromBegin = GetElementSize() * elementNumber;
   ASSERT(Data() + offsetFromBegin <= Data() + m_memory->size(), ());
@@ -43,9 +43,9 @@ void CPUBuffer::Seek(uint16_t elementNumber)
   m_memoryCursor = NonConstData() + offsetFromBegin;
 }
 
-uint16_t CPUBuffer::GetCurrentElementNumber() const
+uint32_t CPUBuffer::GetCurrentElementNumber() const
 {
-  uint16_t pointerDiff = GetCursor() - Data();
+  uint32_t pointerDiff = GetCursor() - Data();
   ASSERT(pointerDiff % GetElementSize() == 0, ());
   return pointerDiff / GetElementSize();
 }
diff --git a/drape/cpu_buffer.hpp b/drape/cpu_buffer.hpp
index dedeca7210..addbce9bff 100644
--- a/drape/cpu_buffer.hpp
+++ b/drape/cpu_buffer.hpp
@@ -12,15 +12,15 @@ class CPUBuffer : public BufferBase
 {
   typedef BufferBase TBase;
 public:
-  CPUBuffer(uint8_t elementSize, uint16_t capacity);
+  CPUBuffer(uint8_t elementSize, uint32_t capacity);
   ~CPUBuffer();
 
-  void UploadData(void const * data, uint16_t elementCount);
+  void UploadData(void const * data, uint32_t elementCount);
   // Set memory cursor on element with number == "elementNumber"
   // Element numbers start from 0
-  void Seek(uint16_t elementNumber);
+  void Seek(uint32_t elementNumber);
   // Check function. In real world use must use it only in assert
-  uint16_t GetCurrentElementNumber() const;
+  uint32_t GetCurrentElementNumber() const;
   unsigned char const * Data() const;
 
 private:
diff --git a/drape/data_buffer.cpp b/drape/data_buffer.cpp
index e9837ad0e2..fccc4fa7f9 100644
--- a/drape/data_buffer.cpp
+++ b/drape/data_buffer.cpp
@@ -4,7 +4,7 @@
 namespace dp
 {
 
-DataBuffer::DataBuffer(uint8_t elementSize, uint16_t capacity)
+DataBuffer::DataBuffer(uint8_t elementSize, uint32_t capacity)
   : m_impl(make_unique_dp<CpuBufferImpl>(elementSize, capacity))
 {
 }
@@ -18,7 +18,7 @@ ref_ptr<DataBufferBase> DataBuffer::GetBuffer() const
 void DataBuffer::MoveToGPU(GPUBuffer::Target target)
 {
   // if currentSize is 0 buffer hasn't been filled on preparation stage, let it be filled further
-  uint16_t const currentSize = m_impl->GetCurrentSize();
+  uint32_t const currentSize = m_impl->GetCurrentSize();
   if (currentSize != 0)
     m_impl = make_unique_dp<GpuBufferImpl>(target, m_impl->Data(),m_impl->GetElementSize(), currentSize);
   else
@@ -38,7 +38,7 @@ DataBufferMapper::~DataBufferMapper()
   m_buffer->GetBuffer()->Unmap();
 }
 
-void DataBufferMapper::UpdateData(void const * data, uint16_t elementOffset, uint16_t elementCount)
+void DataBufferMapper::UpdateData(void const * data, uint32_t elementOffset, uint32_t elementCount)
 {
   m_buffer->GetBuffer()->UpdateData(m_ptr, data, elementOffset, elementCount);
 }
diff --git a/drape/data_buffer.hpp b/drape/data_buffer.hpp
index 8aa9e7ea05..0c82228449 100644
--- a/drape/data_buffer.hpp
+++ b/drape/data_buffer.hpp
@@ -11,15 +11,15 @@ class DataBufferBase
 public:
   virtual ~DataBufferBase() {}
 
-  virtual uint16_t GetCapacity() const = 0;
-  virtual uint16_t GetCurrentSize() const = 0;
-  virtual uint16_t GetAvailableSize() const = 0;
+  virtual uint32_t GetCapacity() const = 0;
+  virtual uint32_t GetCurrentSize() const = 0;
+  virtual uint32_t GetAvailableSize() const = 0;
   virtual uint8_t GetElementSize() const = 0;
-  virtual void Seek(uint16_t elementNumber) = 0;
+  virtual void Seek(uint32_t elementNumber) = 0;
   virtual void const * Data() const = 0;
 
-  virtual void UploadData(void const * data, uint16_t elementCount) = 0;
-  virtual void UpdateData(void * destPtr, void const * srcPtr, uint16_t elementOffset, uint16_t elementCount) = 0;
+  virtual void UploadData(void const * data, uint32_t elementCount) = 0;
+  virtual void UpdateData(void * destPtr, void const * srcPtr, uint32_t elementOffset, uint32_t elementCount) = 0;
 
   virtual void Bind() = 0;
   virtual void * Map() = 0;
@@ -30,7 +30,7 @@ public:
 class DataBuffer
 {
 public:
-  DataBuffer(uint8_t elementSize, uint16_t capacity);
+  DataBuffer(uint8_t elementSize, uint32_t capacity);
 
   ref_ptr<DataBufferBase> GetBuffer() const;
   void MoveToGPU(GPUBuffer::Target target);
@@ -46,7 +46,7 @@ public:
   DataBufferMapper(ref_ptr<DataBuffer> buffer);
   ~DataBufferMapper();
 
-  void UpdateData(void const * data, uint16_t elementOffset, uint16_t elementCount);
+  void UpdateData(void const * data, uint32_t elementOffset, uint32_t elementCount);
 
 private:
   ref_ptr<DataBuffer> m_buffer;
diff --git a/drape/data_buffer_impl.hpp b/drape/data_buffer_impl.hpp
index 818b86e4d9..562e9a0913 100644
--- a/drape/data_buffer_impl.hpp
+++ b/drape/data_buffer_impl.hpp
@@ -18,17 +18,17 @@ public:
   {
   }
 
-  uint16_t GetCapacity() const override
+  uint32_t GetCapacity() const override
   {
     return m_buffer->GetCapacity();
   }
 
-  uint16_t GetCurrentSize() const override
+  uint32_t GetCurrentSize() const override
   {
     return m_buffer->GetCurrentSize();
   }
 
-  uint16_t GetAvailableSize() const override
+  uint32_t GetAvailableSize() const override
   {
     return m_buffer->GetAvailableSize();
   }
@@ -38,7 +38,7 @@ public:
     return m_buffer->GetElementSize();
   }
 
-  void Seek(uint16_t elementNumber) override
+  void Seek(uint32_t elementNumber) override
   {
     m_buffer->Seek(elementNumber);
   }
@@ -60,14 +60,14 @@ public:
     return m_buffer->Data();
   }
 
-  void UploadData(void const * data, uint16_t elementCount) override
+  void UploadData(void const * data, uint32_t elementCount) override
   {
     m_buffer->UploadData(data, elementCount);
-    uint16_t const newOffset = m_buffer->GetCurrentSize();
+    uint32_t const newOffset = m_buffer->GetCurrentSize();
     m_buffer->Seek(newOffset);
   }
 
-  void UpdateData(void * destPtr, void const * srcPtr, uint16_t elementOffset, uint16_t elementCount) override
+  void UpdateData(void * destPtr, void const * srcPtr, uint32_t elementOffset, uint32_t elementCount) override
   {
     ASSERT(false, ("Data updating is unavailable for CPU buffer"));
   }
@@ -103,12 +103,12 @@ public:
     return nullptr;
   }
 
-  void UploadData(void const * data, uint16_t elementCount) override
+  void UploadData(void const * data, uint32_t elementCount) override
   {
     m_buffer->UploadData(data, elementCount);
   }
 
-  void UpdateData(void * destPtr, void const * srcPtr, uint16_t elementOffset, uint16_t elementCount) override
+  void UpdateData(void * destPtr, void const * srcPtr, uint32_t elementOffset, uint32_t elementCount) override
   {
     m_buffer->UpdateData(destPtr, srcPtr, elementOffset, elementCount);
   }
diff --git a/drape/drape_common.pri b/drape/drape_common.pri
index 2256b284b4..1f0d8c141d 100644
--- a/drape/drape_common.pri
+++ b/drape/drape_common.pri
@@ -24,6 +24,7 @@ SOURCES += \
     $$DRAPE_DIR/gpu_program_manager.cpp \
     $$DRAPE_DIR/index_buffer.cpp \
     $$DRAPE_DIR/index_buffer_mutator.cpp \
+    $$DRAPE_DIR/index_storage.cpp \
     $$DRAPE_DIR/oglcontextfactory.cpp \
     $$DRAPE_DIR/overlay_handle.cpp \
     $$DRAPE_DIR/overlay_tree.cpp \
@@ -76,6 +77,7 @@ HEADERS += \
     $$DRAPE_DIR/gpu_program_manager.hpp \
     $$DRAPE_DIR/index_buffer.hpp \
     $$DRAPE_DIR/index_buffer_mutator.hpp \
+    $$DRAPE_DIR/index_storage.hpp \
     $$DRAPE_DIR/object_pool.hpp \
     $$DRAPE_DIR/oglcontext.hpp \
     $$DRAPE_DIR/oglcontextfactory.hpp \
diff --git a/drape/drape_tests/batcher_tests.cpp b/drape/drape_tests/batcher_tests.cpp
index de72a84054..0b8da62565 100644
--- a/drape/drape_tests/batcher_tests.cpp
+++ b/drape/drape_tests/batcher_tests.cpp
@@ -4,6 +4,7 @@
 #include "drape/glconstants.hpp"
 #include "drape/batcher.hpp"
 #include "drape/gpu_program_manager.hpp"
+#include "drape/index_storage.hpp"
 #include "drape/shader_def.hpp"
 #include "drape/vertex_array_buffer.hpp"
 
@@ -49,13 +50,13 @@ public:
   }
 
   template <typename TBatcherCall>
-  void RunTest(float * vertexes, uint16_t * indexes,
-               uint16_t vertexCount, uint16_t vertexComponentCount,
-               uint16_t indexCount, TBatcherCall const & fn)
+  void RunTest(float * vertexes, void * indexes,
+               uint32_t vertexCount, uint32_t vertexComponentCount,
+               uint32_t indexCount, TBatcherCall const & fn)
   {
     int const vertexSize = vertexCount * vertexComponentCount;
     MemoryComparer const dataCmp(vertexes, vertexSize * sizeof(float));
-    MemoryComparer const indexCmp(indexes, indexCount * sizeof(uint16_t));
+    MemoryComparer const indexCmp(indexes, indexCount * dp::IndexStorage::SizeOfIndex());
 
     ExpectBufferCreation(vertexSize, indexCount, indexCmp, dataCmp);
 
@@ -73,7 +74,7 @@ public:
     provider.InitStream(0, binding, make_ref(vertexes));
 
     VAOAcceptor vaoAcceptor;
-    Batcher batcher;
+    Batcher batcher(65000, 65000);
     batcher.StartSession(bind(&VAOAcceptor::FlushFullBucket, &vaoAcceptor, _1, _2));
     fn(&batcher, state, make_ref(&provider));
     batcher.EndSession();
@@ -84,7 +85,7 @@ public:
       vaoAcceptor.m_vao[i].reset();
   }
 
-  void ExpectBufferCreation(uint16_t vertexCount, uint16_t indexCount,
+  void ExpectBufferCreation(uint32_t vertexCount, uint32_t indexCount,
                             MemoryComparer const & indexCmp, MemoryComparer const & vertexCmp)
   {
     InSequence seq;
@@ -98,7 +99,7 @@ public:
     // Index buffer creation
     EXPECTGL(glGenBuffer()).WillOnce(Return(m_indexBufferID));
     EXPECTGL(glBindBuffer(m_indexBufferID, gl_const::GLElementArrayBuffer));
-    EXPECTGL(glBufferData(gl_const::GLElementArrayBuffer, indexCount * sizeof(unsigned short), _, gl_const::GLDynamicDraw))
+    EXPECTGL(glBufferData(gl_const::GLElementArrayBuffer, indexCount * dp::IndexStorage::SizeOfIndex(), _, gl_const::GLDynamicDraw))
         .WillOnce(Invoke(&indexCmp, &MemoryComparer::cmpSubBuffer));
 
     EXPECTGL(glBindBuffer(0, gl_const::GLElementArrayBuffer));
@@ -129,16 +130,17 @@ UNIT_TEST(BatchLists_Test)
   for (int i = 0; i < FLOAT_COUNT; ++i)
     data[i] = (float)i;
 
-  unsigned short indexes[VERTEX_COUNT];
+  vector<uint32_t> indexesRaw(VERTEX_COUNT);
   for (int i = 0; i < VERTEX_COUNT; ++i)
-    indexes[i] = i;
+    indexesRaw[i] = i;
+  dp::IndexStorage indexes(move(indexesRaw));
 
   BatcherExpectations expectations;
   auto fn = [](Batcher * batcher, GLState const & state, ref_ptr<AttributeProvider> p)
   {
     batcher->InsertTriangleList(state, p);
   };
-  expectations.RunTest(data, indexes, VERTEX_COUNT, 3, VERTEX_COUNT, fn);
+  expectations.RunTest(data, indexes.GetRaw(), VERTEX_COUNT, 3, VERTEX_COUNT, fn);
 }
 
 UNIT_TEST(BatchListOfStript_4stride)
@@ -150,8 +152,8 @@ UNIT_TEST(BatchListOfStript_4stride)
   for (int i = 0; i < VERTEX_COUNT * 3; ++i)
     data[i] = (float)i;
 
-  unsigned short indexes[INDEX_COUNT] =
-    { 0, 1, 2, 1, 3, 2, 4, 5, 6, 5, 7, 6, 8, 9, 10, 9, 11, 10};
+  vector<uint32_t> indexesRaw = { 0, 1, 2, 1, 3, 2, 4, 5, 6, 5, 7, 6, 8, 9, 10, 9, 11, 10};
+  dp::IndexStorage indexes(move(indexesRaw));
 
   BatcherExpectations expectations;
   auto fn = [](Batcher * batcher, GLState const & state, ref_ptr<AttributeProvider> p)
@@ -159,7 +161,7 @@ UNIT_TEST(BatchListOfStript_4stride)
     batcher->InsertListOfStrip(state, p, dp::Batcher::VertexPerQuad);
   };
 
-  expectations.RunTest(data, indexes, VERTEX_COUNT, 3, INDEX_COUNT, fn);
+  expectations.RunTest(data, indexes.GetRaw(), VERTEX_COUNT, 3, INDEX_COUNT, fn);
 }
 
 UNIT_TEST(BatchListOfStript_5stride)
@@ -171,7 +173,7 @@ UNIT_TEST(BatchListOfStript_5stride)
   for (int i = 0; i < VERTEX_COUNT * 3; ++i)
     data[i] = (float)i;
 
-  unsigned short indexes[INDEX_COUNT] =
+  vector<uint32_t> indexesRaw =
     { 0, 1, 2,
       1, 3, 2,
       2, 3, 4,
@@ -181,13 +183,14 @@ UNIT_TEST(BatchListOfStript_5stride)
       10, 11, 12,
       11, 13, 12,
       12, 13, 14 };
+  dp::IndexStorage indexes(move(indexesRaw));
 
   BatcherExpectations expectations;
   auto fn = [](Batcher * batcher, GLState const & state, ref_ptr<AttributeProvider> p)
   {
     batcher->InsertListOfStrip(state, p, 5);
   };
-  expectations.RunTest(data, indexes, VERTEX_COUNT, 3, INDEX_COUNT, fn);
+  expectations.RunTest(data, indexes.GetRaw(), VERTEX_COUNT, 3, INDEX_COUNT, fn);
 }
 
 UNIT_TEST(BatchListOfStript_6stride)
@@ -199,7 +202,7 @@ UNIT_TEST(BatchListOfStript_6stride)
   for (int i = 0; i < VERTEX_COUNT * 3; ++i)
     data[i] = (float)i;
 
-  unsigned short indexes[INDEX_COUNT] =
+  vector<uint32_t> indexesRaw =
     { 0, 1, 2,
       1, 3, 2,
       2, 3, 4,
@@ -212,13 +215,14 @@ UNIT_TEST(BatchListOfStript_6stride)
       13, 15, 14,
       14, 15, 16,
       15, 17, 16};
+  dp::IndexStorage indexes(move(indexesRaw));
 
   BatcherExpectations expectations;
   auto fn = [](Batcher * batcher, GLState const & state, ref_ptr<AttributeProvider> p)
   {
     batcher->InsertListOfStrip(state, p, 6);
   };
-  expectations.RunTest(data, indexes, VERTEX_COUNT, 3, INDEX_COUNT, fn);
+  expectations.RunTest(data, indexes.GetRaw(), VERTEX_COUNT, 3, INDEX_COUNT, fn);
 }
 
 namespace
@@ -323,7 +327,7 @@ UNIT_TEST(BatchListOfStript_partial)
   for (uint32_t i = 0; i < VertexArraySize; ++i)
     vertexData[i] = (float)i;
 
-  uint16_t indexData[IndexCount] =
+  vector<uint32_t> indexDataRaw =
     { 0, 1, 2,
       1, 3, 2,
       4, 5, 6,
@@ -332,14 +336,15 @@ UNIT_TEST(BatchListOfStript_partial)
       9, 11, 10,
       0, 1, 2, // start new buffer
       1, 3, 2};
+  dp::IndexStorage indexData(move(indexDataRaw));
 
-  PartialBatcherTest::BufferNode node1(FirstBufferIndexPortion * sizeof(uint16_t),
+  PartialBatcherTest::BufferNode node1(FirstBufferIndexPortion * dp::IndexStorage::SizeOfIndex(),
                                        FirstBufferVertexPortion * ComponentCount * sizeof(float),
-                                       indexData, vertexData);
+                                       indexData.GetRaw(), vertexData);
 
-  PartialBatcherTest::BufferNode node2(SecondBufferIndexPortion * sizeof(uint16_t),
+  PartialBatcherTest::BufferNode node2(SecondBufferIndexPortion * dp::IndexStorage::SizeOfIndex(),
                                        SecondBufferVertexPortion * ComponentCount * sizeof(float),
-                                       indexData + FirstBufferIndexPortion,
+                                       indexData.GetRaw(FirstBufferIndexPortion),
                                        vertexData + FirstBufferVertexPortion * ComponentCount);
 
   typedef pair<uint32_t, uint32_t> IndexVertexCount;
diff --git a/drape/drape_tests/buffer_tests.cpp b/drape/drape_tests/buffer_tests.cpp
index 4fd8350335..1cc91da836 100644
--- a/drape/drape_tests/buffer_tests.cpp
+++ b/drape/drape_tests/buffer_tests.cpp
@@ -5,6 +5,7 @@
 #include "drape/data_buffer.hpp"
 #include "drape/gpu_buffer.hpp"
 #include "drape/index_buffer.hpp"
+#include "drape/index_storage.hpp"
 
 #include "std/cstdlib.hpp"
 #include "std/unique_ptr.hpp"
@@ -36,7 +37,7 @@ UNIT_TEST(CreateDestroyIndexBufferTest)
   InSequence s;
   EXPECTGL(glGenBuffer()).WillOnce(Return(1));
   EXPECTGL(glBindBuffer(1, gl_const::GLElementArrayBuffer));
-  EXPECTGL(glBufferData(gl_const::GLElementArrayBuffer, 100 * sizeof(uint16_t), NULL, gl_const::GLDynamicDraw));
+  EXPECTGL(glBufferData(gl_const::GLElementArrayBuffer, 100 * dp::IndexStorage::SizeOfIndex(), NULL, gl_const::GLDynamicDraw));
   EXPECTGL(glBindBuffer(0, gl_const::GLElementArrayBuffer));
   EXPECTGL(glDeleteBuffer(1));
 
diff --git a/drape/drape_tests/glfunctions.cpp b/drape/drape_tests/glfunctions.cpp
index 3d93fe6bc9..16c39fd67b 100644
--- a/drape/drape_tests/glfunctions.cpp
+++ b/drape/drape_tests/glfunctions.cpp
@@ -255,7 +255,7 @@ void * GLFunctions::glMapBuffer(glConst target) { return 0; }
 
 void GLFunctions::glUnmapBuffer(glConst target) {}
 
-void GLFunctions::glDrawElements(uint16_t indexCount, uint16_t startIndex) {}
+void GLFunctions::glDrawElements(bool use32bits, uint32_t indexCount, uint32_t startIndex) {}
 
 void GLFunctions::glPixelStore(glConst name, uint32_t value) {}
 
diff --git a/drape/glextensions_list.cpp b/drape/glextensions_list.cpp
index 5948f2fb64..f34b629d62 100644
--- a/drape/glextensions_list.cpp
+++ b/drape/glextensions_list.cpp
@@ -85,16 +85,19 @@ GLExtensionsList::GLExtensionsList()
   m_impl->CheckExtension(RequiredInternalFormat, "GL_OES_required_internalformat");
   m_impl->CheckExtension(TextureNPOT, "GL_OES_texture_npot");
   m_impl->CheckExtension(MapBuffer, "GL_OES_mapbuffer");
+  m_impl->CheckExtension(UintIndices, "GL_OES_element_index_uint");
 #elif defined(OMIM_OS_WINDOWS)
   m_impl->CheckExtension(TextureNPOT, "GL_ARB_texture_non_power_of_two");
   m_impl->SetExtension(VertexArrayObject, false);
   m_impl->SetExtension(RequiredInternalFormat, false);
   m_impl->SetExtension(MapBuffer, true);
+  m_impl->SetExtension(UintIndices, true);
 #else
   m_impl->CheckExtension(VertexArrayObject, "GL_APPLE_vertex_array_object");
   m_impl->CheckExtension(TextureNPOT, "GL_ARB_texture_non_power_of_two");
   m_impl->SetExtension(RequiredInternalFormat, false);
   m_impl->SetExtension(MapBuffer, true);
+  m_impl->SetExtension(UintIndices, true);
 #endif
 }
 
diff --git a/drape/glextensions_list.hpp b/drape/glextensions_list.hpp
index 49b36ebfce..623e8e55dc 100644
--- a/drape/glextensions_list.hpp
+++ b/drape/glextensions_list.hpp
@@ -13,7 +13,8 @@ public:
     VertexArrayObject,
     TextureNPOT,
     RequiredInternalFormat,
-    MapBuffer
+    MapBuffer,
+    UintIndices,
   };
 
   static GLExtensionsList & Instance();
diff --git a/drape/glfunctions.cpp b/drape/glfunctions.cpp
index 3ac7a460ad..95515416af 100644
--- a/drape/glfunctions.cpp
+++ b/drape/glfunctions.cpp
@@ -777,10 +777,11 @@ void GLFunctions::glTexParameter(glConst param, glConst value)
   GLCHECK(::glTexParameteri(GL_TEXTURE_2D, param, value));
 }
 
-void GLFunctions::glDrawElements(uint16_t indexCount, uint16_t startIndex)
+void GLFunctions::glDrawElements(bool use32bits, uint32_t indexCount, uint32_t startIndex)
 {
-  GLCHECK(::glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT,
-                           reinterpret_cast<GLvoid *>(startIndex * sizeof(uint16_t))));
+  uint32_t const sizeOfIndex = use32bits ? sizeof(uint32_t) : sizeof(uint16_t);
+  GLCHECK(::glDrawElements(GL_TRIANGLES, indexCount, use32bits ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT,
+                           reinterpret_cast<GLvoid *>(startIndex * sizeOfIndex)));
 }
 
 namespace
diff --git a/drape/glfunctions.hpp b/drape/glfunctions.hpp
index a7c5273396..7ad2e0150c 100644
--- a/drape/glfunctions.hpp
+++ b/drape/glfunctions.hpp
@@ -121,7 +121,7 @@ public:
   static void glTexParameter(glConst param, glConst value);
 
   // Draw support
-  static void glDrawElements(uint16_t indexCount, uint16_t startIndex = 0);
+  static void glDrawElements(bool use32bits, uint32_t indexCount, uint32_t startIndex = 0);
 };
 
 void CheckGLError(my::SrcPoint const &src);
diff --git a/drape/gpu_buffer.cpp b/drape/gpu_buffer.cpp
index dc1b0a4534..5d91dc06f2 100644
--- a/drape/gpu_buffer.cpp
+++ b/drape/gpu_buffer.cpp
@@ -29,7 +29,7 @@ glConst glTarget(GPUBuffer::Target t)
   return gl_const::GLElementArrayBuffer;
 }
 
-GPUBuffer::GPUBuffer(Target t, void const * data, uint8_t elementSize, uint16_t capacity)
+GPUBuffer::GPUBuffer(Target t, void const * data, uint8_t elementSize, uint32_t capacity)
   : TBase(elementSize, capacity)
   , m_t(t)
 #ifdef DEBUG
@@ -49,11 +49,11 @@ GPUBuffer::~GPUBuffer()
 #endif
 }
 
-void GPUBuffer::UploadData(void const * data, uint16_t elementCount)
+void GPUBuffer::UploadData(void const * data, uint32_t elementCount)
 {
   ASSERT(m_isMapped == false, ());
 
-  uint16_t currentSize = GetCurrentSize();
+  uint32_t currentSize = GetCurrentSize();
   uint8_t elementSize = GetElementSize();
   ASSERT(GetCapacity() >= elementCount + currentSize, ("Not enough memory to upload ", elementCount, " elements"));
   Bind();
@@ -90,9 +90,9 @@ void * GPUBuffer::Map()
   return NULL;
 }
 
-void GPUBuffer::UpdateData(void * gpuPtr, void const * data, uint16_t elementOffset, uint16_t elementCount)
+void GPUBuffer::UpdateData(void * gpuPtr, void const * data, uint32_t elementOffset, uint32_t elementCount)
 {
-  uint32_t const elementSize = static_cast<uint32_t>(GetElementSize());
+  uint32_t const elementSize = GetElementSize();
   uint32_t const byteOffset = elementOffset * elementSize;
   uint32_t const byteCount = elementCount * elementSize;
   uint32_t const byteCapacity = GetCapacity() * elementSize;
@@ -129,7 +129,7 @@ void GPUBuffer::Unmap()
     GLFunctions::glUnmapBuffer(glTarget(m_t));
 }
 
-void GPUBuffer::Resize(void const * data, uint16_t elementCount)
+void GPUBuffer::Resize(void const * data, uint32_t elementCount)
 {
   TBase::Resize(elementCount);
   Bind();
diff --git a/drape/gpu_buffer.hpp b/drape/gpu_buffer.hpp
index 3197e0a84b..ec65cd47d7 100644
--- a/drape/gpu_buffer.hpp
+++ b/drape/gpu_buffer.hpp
@@ -17,19 +17,19 @@ public:
   };
 
 public:
-  GPUBuffer(Target t, void const * data, uint8_t elementSize, uint16_t capacity);
+  GPUBuffer(Target t, void const * data, uint8_t elementSize, uint32_t capacity);
   ~GPUBuffer();
 
-  void UploadData(void const * data, uint16_t elementCount);
+  void UploadData(void const * data, uint32_t elementCount);
   void Bind();
 
   void * Map();
-  void UpdateData(void * gpuPtr, void const * data, uint16_t elementOffset, uint16_t elementCount);
+  void UpdateData(void * gpuPtr, void const * data, uint32_t elementOffset, uint32_t elementCount);
   void Unmap();
 
 protected:
   /// discard old data
-  void Resize(void const * data, uint16_t elementCount);
+  void Resize(void const * data, uint32_t elementCount);
 
 private:
   friend class GPUBufferMapper;
diff --git a/drape/index_buffer.cpp b/drape/index_buffer.cpp
index 486ae8b1d9..cf8aab332b 100644
--- a/drape/index_buffer.cpp
+++ b/drape/index_buffer.cpp
@@ -1,19 +1,20 @@
 #include "drape/index_buffer.hpp"
+#include "drape/index_storage.hpp"
 
 namespace dp
 {
 
-IndexBuffer::IndexBuffer(uint16_t capacity)
-  : DataBuffer(sizeof(uint16_t), capacity)
+IndexBuffer::IndexBuffer(uint32_t capacity)
+  : DataBuffer((uint8_t)IndexStorage::SizeOfIndex(), capacity)
 {
 }
 
-void IndexBuffer::UploadData(uint16_t const * data, uint16_t size)
+void IndexBuffer::UploadData(void const * data, uint32_t size)
 {
   GetBuffer()->UploadData((void const *)data, size);
 }
 
-void IndexBuffer::UpdateData(uint16_t const * data, uint16_t size)
+void IndexBuffer::UpdateData(void const * data, uint32_t size)
 {
   ASSERT_LESS_OR_EQUAL(size, GetBuffer()->GetCapacity(), ());
 
diff --git a/drape/index_buffer.hpp b/drape/index_buffer.hpp
index 922d9516dd..85509b85be 100644
--- a/drape/index_buffer.hpp
+++ b/drape/index_buffer.hpp
@@ -8,12 +8,12 @@ namespace dp
 class IndexBuffer : public DataBuffer
 {
 public:
-  IndexBuffer(uint16_t capacity);
+  IndexBuffer(uint32_t capacity);
 
   /// check size of buffer and size of uploaded data
-  void UploadData(uint16_t const * data, uint16_t size);
+  void UploadData(void const * data, uint32_t size);
   /// resize buffer to new size, and discard old data
-  void UpdateData(uint16_t const * data, uint16_t size);
+  void UpdateData(void const * data, uint32_t size);
 };
 
 } // namespace dp
diff --git a/drape/index_buffer_mutator.cpp b/drape/index_buffer_mutator.cpp
index 6634e00594..b0d5858416 100644
--- a/drape/index_buffer_mutator.cpp
+++ b/drape/index_buffer_mutator.cpp
@@ -7,28 +7,28 @@
 namespace dp
 {
 
-IndexBufferMutator::IndexBufferMutator(uint16_t baseSize)
+IndexBufferMutator::IndexBufferMutator(uint32_t baseSize)
   : m_activeSize(0)
 {
-  m_buffer.resize(baseSize);
+  m_buffer.Resize(baseSize);
 }
 
-void IndexBufferMutator::AppendIndexes(uint16_t const * indexes, uint16_t count)
+void IndexBufferMutator::AppendIndexes(void const * indexes, uint32_t count)
 {
-  size_t dstActiveSize = m_activeSize + count;
-  if (dstActiveSize  > m_buffer.size())
-    m_buffer.resize(max(m_buffer.size() * 2, dstActiveSize));
+  uint32_t dstActiveSize = m_activeSize + count;
+  if (dstActiveSize  > m_buffer.Size())
+    m_buffer.Resize(max(m_buffer.Size() * 2, dstActiveSize));
 
-  memcpy(&m_buffer[m_activeSize], indexes, count * sizeof(uint16_t));
+  memcpy(m_buffer.GetRaw(m_activeSize), indexes, count * IndexStorage::SizeOfIndex());
   m_activeSize = dstActiveSize;
 }
 
-uint16_t const * IndexBufferMutator::GetIndexes() const
+void const * IndexBufferMutator::GetIndexes() const
 {
-  return &m_buffer[0];
+  return m_buffer.GetRawConst();
 }
 
-uint16_t IndexBufferMutator::GetIndexCount() const
+uint32_t IndexBufferMutator::GetIndexCount() const
 {
   return m_activeSize;
 }
diff --git a/drape/index_buffer_mutator.hpp b/drape/index_buffer_mutator.hpp
index 06799d3138..5f6b1ec69f 100644
--- a/drape/index_buffer_mutator.hpp
+++ b/drape/index_buffer_mutator.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "drape/index_storage.hpp"
 #include "drape/pointers.hpp"
 
 namespace dp
@@ -10,18 +11,18 @@ class VertexArrayBuffer;
 class IndexBufferMutator
 {
 public:
-  IndexBufferMutator(uint16_t baseSize);
+  IndexBufferMutator(uint32_t baseSize);
 
-  void AppendIndexes(uint16_t const * indexes, uint16_t count);
+  void AppendIndexes(void const * indexes, uint32_t count);
 
 private:
   friend class VertexArrayBuffer;
-  uint16_t const * GetIndexes() const;
-  uint16_t GetIndexCount() const;
+  void const * GetIndexes() const;
+  uint32_t GetIndexCount() const;
 
 private:
-  vector<uint16_t> m_buffer;
-  uint16_t m_activeSize;
+  IndexStorage m_buffer;
+  uint32_t m_activeSize;
 };
 
 } // namespace dp
diff --git a/drape/index_storage.cpp b/drape/index_storage.cpp
new file mode 100644
index 0000000000..3b08dd0b88
--- /dev/null
+++ b/drape/index_storage.cpp
@@ -0,0 +1,59 @@
+#include "drape/index_storage.hpp"
+#include "drape/glextensions_list.hpp"
+
+#include "std/utility.hpp"
+
+namespace dp
+{
+
+IndexStorage::IndexStorage(vector<uint32_t> && initial)
+{
+  if (IsSupported32bit())
+  {
+    m_storage32bit = move(initial);
+  }
+  else
+  {
+    m_storage16bit.reserve(initial.size());
+    for (size_t i = 0; i < initial.size(); i++)
+      m_storage16bit.push_back((uint16_t)initial[i]);
+  }
+}
+
+void IndexStorage::Resize(uint32_t size)
+{
+  if (IsSupported32bit())
+    m_storage32bit.resize(size);
+  else
+    m_storage16bit.resize(size);
+}
+
+uint32_t IndexStorage::Size() const
+{
+  return IsSupported32bit() ? (uint32_t)m_storage32bit.size() : (uint32_t)m_storage16bit.size();
+}
+
+void * IndexStorage::GetRaw(uint32_t offsetInElements)
+{
+  return IsSupported32bit() ? static_cast<void *>(&m_storage32bit[offsetInElements]) :
+                              static_cast<void *>(&m_storage16bit[offsetInElements]);
+}
+
+void const * IndexStorage::GetRawConst() const
+{
+  return IsSupported32bit() ? static_cast<void const *>(m_storage32bit.data()) :
+                              static_cast<void const *>(m_storage16bit.data());
+}
+
+bool IndexStorage::IsSupported32bit()
+{
+  static bool const supports32bit = GLExtensionsList::Instance().IsSupported(GLExtensionsList::UintIndices);
+  return supports32bit;
+}
+
+uint32_t IndexStorage::SizeOfIndex()
+{
+  return IsSupported32bit() ? sizeof(uint32_t) : sizeof(uint16_t);
+}
+
+}
diff --git a/drape/index_storage.hpp b/drape/index_storage.hpp
new file mode 100644
index 0000000000..6ae9d8c3a7
--- /dev/null
+++ b/drape/index_storage.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "std/vector.hpp"
+
+namespace dp
+{
+
+class IndexStorage
+{
+public:
+  IndexStorage() = default;
+  IndexStorage(vector<uint32_t> && initial);
+
+  uint32_t Size() const;
+  void Resize(uint32_t size);
+
+  void * GetRaw(uint32_t offsetInElements = 0);
+  void const * GetRawConst() const;
+
+  static bool IsSupported32bit();
+  static uint32_t SizeOfIndex();
+
+private:
+  vector<uint16_t> m_storage16bit;
+  vector<uint32_t> m_storage32bit;
+};
+
+
+} // namespace dp
diff --git a/drape/overlay_handle.cpp b/drape/overlay_handle.cpp
index 955407f644..2d9c436869 100644
--- a/drape/overlay_handle.cpp
+++ b/drape/overlay_handle.cpp
@@ -75,16 +75,16 @@ bool OverlayHandle::IsIntersect(ScreenBase const & screen, ref_ptr<OverlayHandle
   return false;
 }
 
-uint16_t * OverlayHandle::IndexStorage(uint16_t size)
+void * OverlayHandle::IndexStorage(uint32_t size)
 {
-  m_indexes.resize(size);
-  return &m_indexes[0];
+  m_indexes.Resize(size);
+  return m_indexes.GetRaw();
 }
 
 void OverlayHandle::GetElementIndexes(ref_ptr<IndexBufferMutator> mutator) const
 {
   ASSERT_EQUAL(m_isVisible, true, ());
-  mutator->AppendIndexes(&m_indexes[0], m_indexes.size());
+  mutator->AppendIndexes(m_indexes.GetRawConst(), m_indexes.Size());
 }
 
 void OverlayHandle::GetAttributeMutation(ref_ptr<AttributeBufferMutator> mutator, ScreenBase const & screen) const
@@ -98,7 +98,7 @@ bool OverlayHandle::HasDynamicAttributes() const
   return !m_offsets.empty();
 }
 
-void OverlayHandle::AddDynamicAttribute(BindingInfo const & binding, uint16_t offset, uint16_t count)
+void OverlayHandle::AddDynamicAttribute(BindingInfo const & binding, uint32_t offset, uint32_t count)
 {
   ASSERT(binding.IsDynamic(), ());
   ASSERT(find_if(m_offsets.begin(), m_offsets.end(), OffsetNodeFinder(binding.GetID())) == m_offsets.end(), ());
diff --git a/drape/overlay_handle.hpp b/drape/overlay_handle.hpp
index 855f393792..83a9707745 100644
--- a/drape/overlay_handle.hpp
+++ b/drape/overlay_handle.hpp
@@ -3,6 +3,7 @@
 #include "drape/drape_global.hpp"
 #include "drape/binding_info.hpp"
 #include "drape/index_buffer_mutator.hpp"
+#include "drape/index_storage.hpp"
 #include "drape/attribute_buffer_mutator.hpp"
 
 #include "indexer/feature_decl.hpp"
@@ -42,12 +43,12 @@ public:
   bool IsIntersect(ScreenBase const & screen, ref_ptr<OverlayHandle> const h) const;
 
   virtual bool IndexesRequired() const { return true; }
-  uint16_t * IndexStorage(uint16_t size);
+  void * IndexStorage(uint32_t size);
   void GetElementIndexes(ref_ptr<IndexBufferMutator> mutator) const;
   virtual void GetAttributeMutation(ref_ptr<AttributeBufferMutator> mutator, ScreenBase const & screen) const;
 
   bool HasDynamicAttributes() const;
-  void AddDynamicAttribute(BindingInfo const & binding, uint16_t offset, uint16_t count);
+  void AddDynamicAttribute(BindingInfo const & binding, uint32_t offset, uint32_t count);
 
   FeatureID const & GetFeatureID() const;
   double const & GetPriority() const;
@@ -67,7 +68,7 @@ private:
   bool m_isVisible;
   bool m_isValid;
 
-  vector<uint16_t> m_indexes;
+  dp::IndexStorage m_indexes;
   struct LessOffsetNode
   {
     bool operator()(TOffsetNode const & node1, TOffsetNode const & node2) const
diff --git a/drape/vertex_array_buffer.cpp b/drape/vertex_array_buffer.cpp
index 33eb74f791..2b4625c3a2 100644
--- a/drape/vertex_array_buffer.cpp
+++ b/drape/vertex_array_buffer.cpp
@@ -65,9 +65,12 @@ void VertexArrayBuffer::RenderRange(IndicesRange const & range)
     else
       BindStaticBuffers();
 
+    // here we have to be sure that 32-bit indices are supported
+    bool const supports32bit = GLExtensionsList::Instance().IsSupported(GLExtensionsList::UintIndices);
+
     BindDynamicBuffers();
     GetIndexBuffer()->Bind();
-    GLFunctions::glDrawElements(range.m_idxCount, range.m_idxStart);
+    GLFunctions::glDrawElements(supports32bit, range.m_idxCount, range.m_idxStart);
   }
 }
 
@@ -87,7 +90,7 @@ void VertexArrayBuffer::Build(ref_ptr<GpuProgram> program)
   BindStaticBuffers();
 }
 
-void VertexArrayBuffer::UploadData(BindingInfo const & bindingInfo, void const * data, uint16_t count)
+void VertexArrayBuffer::UploadData(BindingInfo const & bindingInfo, void const * data, uint32_t count)
 {
   ref_ptr<DataBuffer> buffer;
   if (!bindingInfo.IsDynamic())
@@ -148,19 +151,19 @@ ref_ptr<DataBuffer> VertexArrayBuffer::GetOrCreateBuffer(BindingInfo const & bin
   return make_ref(it->second);
 }
 
-uint16_t VertexArrayBuffer::GetAvailableIndexCount() const
+uint32_t VertexArrayBuffer::GetAvailableIndexCount() const
 {
   return GetIndexBuffer()->GetAvailableSize();
 }
 
-uint16_t VertexArrayBuffer::GetAvailableVertexCount() const
+uint32_t VertexArrayBuffer::GetAvailableVertexCount() const
 {
   if (m_staticBuffers.empty())
     return m_dataBufferSize;
 
 #ifdef DEBUG
   TBuffersMap::const_iterator it = m_staticBuffers.begin();
-  uint16_t prev = it->second->GetBuffer()->GetAvailableSize();
+  uint32_t prev = it->second->GetBuffer()->GetAvailableSize();
   for (; it != m_staticBuffers.end(); ++it)
     ASSERT(prev == it->second->GetBuffer()->GetAvailableSize(), ());
 #endif
@@ -168,14 +171,14 @@ uint16_t VertexArrayBuffer::GetAvailableVertexCount() const
   return m_staticBuffers.begin()->second->GetBuffer()->GetAvailableSize();
 }
 
-uint16_t VertexArrayBuffer::GetStartIndexValue() const
+uint32_t VertexArrayBuffer::GetStartIndexValue() const
 {
   if (m_staticBuffers.empty())
     return 0;
 
 #ifdef DEBUG
   TBuffersMap::const_iterator it = m_staticBuffers.begin();
-  uint16_t prev = it->second->GetBuffer()->GetCurrentSize();
+  uint32_t prev = it->second->GetBuffer()->GetCurrentSize();
   for (; it != m_staticBuffers.end(); ++it)
     ASSERT(prev == it->second->GetBuffer()->GetCurrentSize(), ());
 #endif
@@ -183,17 +186,17 @@ uint16_t VertexArrayBuffer::GetStartIndexValue() const
   return m_staticBuffers.begin()->second->GetBuffer()->GetCurrentSize();
 }
 
-uint16_t VertexArrayBuffer::GetDynamicBufferOffset(BindingInfo const & bindingInfo)
+uint32_t VertexArrayBuffer::GetDynamicBufferOffset(BindingInfo const & bindingInfo)
 {
   return GetOrCreateDynamicBuffer(bindingInfo)->GetBuffer()->GetCurrentSize();
 }
 
-uint16_t VertexArrayBuffer::GetIndexCount() const
+uint32_t VertexArrayBuffer::GetIndexCount() const
 {
   return GetIndexBuffer()->GetCurrentSize();
 }
 
-void VertexArrayBuffer::UploadIndexes(uint16_t const * data, uint16_t count)
+void VertexArrayBuffer::UploadIndexes(void const * data, uint32_t count)
 {
   ASSERT(count <= GetIndexBuffer()->GetAvailableSize(), ());
   GetIndexBuffer()->UploadData(data, count);
diff --git a/drape/vertex_array_buffer.hpp b/drape/vertex_array_buffer.hpp
index 37f2f2d802..a153aa408a 100644
--- a/drape/vertex_array_buffer.hpp
+++ b/drape/vertex_array_buffer.hpp
@@ -15,14 +15,14 @@ namespace dp
 
 struct IndicesRange
 {
-  uint16_t m_idxStart;
-  uint16_t m_idxCount;
+  uint32_t m_idxStart;
+  uint32_t m_idxCount;
 
   IndicesRange()
     : m_idxStart(0), m_idxCount(0)
   {}
 
-  IndicesRange(uint16_t idxStart, uint16_t idxCount)
+  IndicesRange(uint32_t idxStart, uint32_t idxCount)
     : m_idxStart(idxStart), m_idxCount(idxCount)
   {}
 
@@ -48,14 +48,14 @@ public:
   void Build(ref_ptr<GpuProgram> program);
   ///@}
 
-  uint16_t GetAvailableVertexCount() const;
-  uint16_t GetAvailableIndexCount() const;
-  uint16_t GetStartIndexValue() const;
-  uint16_t GetDynamicBufferOffset(BindingInfo const & bindingInfo);
-  uint16_t GetIndexCount() const;
+  uint32_t GetAvailableVertexCount() const;
+  uint32_t GetAvailableIndexCount() const;
+  uint32_t GetStartIndexValue() const;
+  uint32_t GetDynamicBufferOffset(BindingInfo const & bindingInfo);
+  uint32_t GetIndexCount() const;
 
-  void UploadData(BindingInfo const & bindingInfo, void const * data, uint16_t count);
-  void UploadIndexes(uint16_t const * data, uint16_t count);
+  void UploadData(BindingInfo const & bindingInfo, void const * data, uint32_t count);
+  void UploadIndexes(void const * data, uint32_t count);
 
   void ApplyMutation(ref_ptr<IndexBufferMutator> indexMutator,
                      ref_ptr<AttributeBufferMutator> attrMutator);
diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp
index fa610da740..0689927769 100644
--- a/drape_frontend/backend_renderer.cpp
+++ b/drape_frontend/backend_renderer.cpp
@@ -25,7 +25,6 @@ namespace df
 BackendRenderer::BackendRenderer(Params const & params)
   : BaseRenderer(ThreadsCommutator::ResourceUploadThread, params)
   , m_model(params.m_model)
-  , m_batchersPool(make_unique_dp<BatchersPool>(ReadManager::ReadCount(), bind(&BackendRenderer::FlushGeometry, this, _1)))
   , m_readManager(make_unique_dp<ReadManager>(params.m_commutator, m_model))
 {
   gui::DrapeGui::Instance().SetRecacheCountryStatusSlot([this]()
@@ -233,6 +232,10 @@ void BackendRenderer::Routine::Do()
   m_renderer.m_contextFactory->getResourcesUploadContext()->makeCurrent();
   GLFunctions::Init();
 
+  // initialize batchers pool after OGL context creation
+  m_renderer.m_batchersPool = make_unique_dp<BatchersPool>(ReadManager::ReadCount(),
+                                                           bind(&BackendRenderer::FlushGeometry, &m_renderer, _1));
+
   m_renderer.InitGLDependentResource();
 
   while (!IsCancelled())
diff --git a/drape_frontend/gui/button.cpp b/drape_frontend/gui/button.cpp
index e87fab0e85..94851eaff2 100644
--- a/drape_frontend/gui/button.cpp
+++ b/drape_frontend/gui/button.cpp
@@ -144,7 +144,7 @@ void Button::Draw(Params const & params, ShapeControl & control, ref_ptr<dp::Tex
 
     ApplyAnchor(params.m_anchor, vertexes, halfWidth, halfHeight);
 
-    uint16_t const verticesCount = (uint16_t)vertexes.size();
+    uint32_t const verticesCount = (uint32_t)vertexes.size();
     dp::AttributeProvider provider(1 /* stream count */, verticesCount);
     provider.InitStream(0 /*stream index*/, ButtonVertex::GetBindingInfo(),
                         make_ref(vertexes.data()));
diff --git a/drape_head/testing_engine.cpp b/drape_head/testing_engine.cpp
index 7b3905b014..12e140cf2b 100644
--- a/drape_head/testing_engine.cpp
+++ b/drape_head/testing_engine.cpp
@@ -347,7 +347,7 @@ TestingEngine::TestingEngine(ref_ptr<dp::OGLContextFactory> oglcontextfactory,
   m_textures = make_unique_dp<dp::TextureManager>();
   m_textures->Init(params);
 
-  m_batcher = make_unique_dp<dp::Batcher>();
+  m_batcher = make_unique_dp<dp::Batcher>(65000, 65000);
   m_programManager = make_unique_dp<dp::GpuProgramManager>();
 
   ModelViewInit();