[vulkan] Added descriptor sets

11 files changed, 219 insertions, 71 deletions

diff --git a/drape/render_state.cpp b/drape/render_state.cpp
index dbe0844f7b..18985d0114 100644
--- a/drape/render_state.cpp
+++ b/drape/render_state.cpp
@@ -237,12 +237,13 @@ void TextureState::ApplyTextures(ref_ptr<GraphicsContext> context, RenderState c
       CHECK(it != bindings.end(), ("Texture bindings inconsistency."));
 
       ref_ptr<dp::vulkan::VulkanTexture> t = texture.second->GetHardwareTexture();
+      t->SetFilter(state.GetTextureFilter());
 
       dp::vulkan::ParamDescriptor descriptor;
       descriptor.m_type = dp::vulkan::ParamDescriptor::Type::Texture;
       descriptor.m_imageDescriptor.imageView = t->GetTextureView();
+      descriptor.m_imageDescriptor.sampler = vulkanContext->GetSampler(t->GetSamplerKey());
       descriptor.m_imageDescriptor.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-      //descriptor.m_imageDescriptor.sampler =; //TODO(@rokuz, @darina): Implement.
       descriptor.m_textureSlot = it->second;
       vulkanContext->ApplyParamDescriptor(std::move(descriptor));
     }
diff --git a/drape/vulkan/vulkan_base_context.cpp b/drape/vulkan/vulkan_base_context.cpp
index 215faac3f5..1e04b8dcad 100644
--- a/drape/vulkan/vulkan_base_context.cpp
+++ b/drape/vulkan/vulkan_base_context.cpp
@@ -31,7 +31,6 @@ VulkanBaseContext::VulkanBaseContext(VkInstance vulkanInstance, VkPhysicalDevice
   vkGetDeviceQueue(m_device, m_renderingQueueFamilyIndex, 0, &m_queue);
 }
 
-
 VulkanBaseContext::~VulkanBaseContext()
 {
   if (m_pipeline)
@@ -40,6 +39,10 @@ VulkanBaseContext::~VulkanBaseContext()
     m_pipeline.reset();
   }
 
+  for (auto const & s : m_samplers)
+    vkDestroySampler(m_device, s.second, nullptr);
+  m_samplers.clear();
+
   DestroyDescriptorPools();
   DestroyDefaultFramebuffer();
   DestroyDepthTexture();
@@ -92,6 +95,8 @@ void VulkanBaseContext::SetFramebuffer(ref_ptr<dp::BaseFramebuffer> framebuffer)
 
 void VulkanBaseContext::ApplyFramebuffer(std::string const & framebufferLabel)
 {
+  //TODO: set renderPass to m_pipelineKey
+  vkCmdSetStencilReference(m_commandBuffer, VK_STENCIL_FRONT_AND_BACK, m_stencilReferenceValue);
 }
 
 void VulkanBaseContext::Init(ApiVersion apiVersion)
@@ -277,6 +282,10 @@ void VulkanBaseContext::Present()
   // only after the finishing of rendering. It prevents data collisions.
   m_objectManager->ResetDefaultStagingBuffer();
   m_objectManager->CollectObjects();
+
+  m_pipelineKey = {};
+  m_stencilReferenceValue = 1;
+  ClearParamDescriptors();
 }
 
 uint32_t VulkanBaseContext::RegisterHandler(HandlerType handlerType, ContextHandler && handler)
@@ -595,32 +604,28 @@ void VulkanBaseContext::DestroyDescriptorPools()
 
 void VulkanBaseContext::SetDepthTestEnabled(bool enabled)
 {
-  m_depthEnabled = enabled;
+  m_pipelineKey.m_depthStencil.SetDepthTestEnabled(enabled);
 }
 
 void VulkanBaseContext::SetDepthTestFunction(TestFunction depthFunction)
 {
-  m_depthFunction = depthFunction;
+  m_pipelineKey.m_depthStencil.SetDepthTestFunction(depthFunction);
 }
 
 void VulkanBaseContext::SetStencilTestEnabled(bool enabled)
 {
-  m_stencilEnabled = enabled;
+  m_pipelineKey.m_depthStencil.SetStencilTestEnabled(enabled);
 }
 
 void VulkanBaseContext::SetStencilFunction(StencilFace face, TestFunction stencilFunction)
 {
-  m_stencilFunctionFace = face;
-  m_stencilFunction = stencilFunction;
+  m_pipelineKey.m_depthStencil.SetStencilFunction(face, stencilFunction);
 }
 
 void VulkanBaseContext::SetStencilActions(StencilFace face, StencilAction stencilFailAction,
                                           StencilAction depthFailAction, StencilAction passAction)
 {
-  m_stencilActionFace = face;
-  m_stencilFailAction = stencilFailAction;
-  m_depthFailAction = depthFailAction;
-  m_passAction = passAction;
+  m_pipelineKey.m_depthStencil.SetStencilActions(face, stencilFailAction, depthFailAction, passAction);
 }
 
 void VulkanBaseContext::SetStencilReferenceValue(uint32_t stencilReferenceValue)
@@ -630,22 +635,22 @@ void VulkanBaseContext::SetStencilReferenceValue(uint32_t stencilReferenceValue)
     
 void VulkanBaseContext::SetPrimitiveTopology(VkPrimitiveTopology topology)
 {
-  //TODO
+  m_pipelineKey.m_primitiveTopology = topology;
 }
     
 void VulkanBaseContext::SetBindingInfo(std::vector<dp::BindingInfo> const & bindingInfo)
 {
-  //TODO
+  m_pipelineKey.m_bindingInfo = bindingInfo;
 }
 
 void VulkanBaseContext::SetProgram(ref_ptr<VulkanGpuProgram> program)
 {
-  m_currentProgram = program;
+  m_pipelineKey.m_program = program;
 }
     
 void VulkanBaseContext::SetBlendingEnabled(bool blendingEnabled)
 {
-  //TODO
+  m_pipelineKey.m_blendingEnabled = blendingEnabled;
 }
     
 void VulkanBaseContext::ApplyParamDescriptor(ParamDescriptor && descriptor)
@@ -660,18 +665,17 @@ void VulkanBaseContext::ClearParamDescriptors()
 
 VkPipeline VulkanBaseContext::GetCurrentPipeline()
 {
-  //TODO
-  return {};
+  return m_pipeline->GetPipeline(m_device, m_pipelineKey);
 }
 
-DescriptorSet VulkanBaseContext::GetCurrentDescriptorSet()
+DescriptorSetGroup VulkanBaseContext::GetCurrentDescriptorSetGroup()
 {
   CHECK(!m_descriptorPools.empty(), ());
-  CHECK(m_currentProgram != nullptr, ());
-  CHECK(!m_paramDescriptors.empty(), ());
+  CHECK(m_pipelineKey.m_program != nullptr, ());
+  CHECK(!m_paramDescriptors.empty(), ("Shaders parameters are not set."));
 
-  DescriptorSet s;
-  VkDescriptorSetLayout layout = m_currentProgram->GetDescriptorSetLayout();
+  DescriptorSetGroup s;
+  VkDescriptorSetLayout layout = m_pipelineKey.m_program->GetDescriptorSetLayout();
   VkDescriptorSetAllocateInfo allocInfo = {};
   allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
   allocInfo.descriptorPool = s.m_descriptorPool = m_descriptorPools.front();
@@ -726,8 +730,43 @@ DescriptorSet VulkanBaseContext::GetCurrentDescriptorSet()
 
   vkUpdateDescriptorSets(m_device, static_cast<uint32_t>(writeDescriptorSets.size()),
                          writeDescriptorSets.data(), 0, nullptr);
-
   return s;
 }
+
+VkPipelineLayout VulkanBaseContext::GetCurrentPipelineLayout() const
+{
+  CHECK(m_pipelineKey.m_program != nullptr, ());
+  return m_pipelineKey.m_program->GetPipelineLayout();
+}
+
+uint32_t VulkanBaseContext::GetCurrentDynamicBufferOffset() const
+{
+  for (auto const & p : m_paramDescriptors)
+  {
+    if (p.m_type == ParamDescriptor::Type::DynamicUniformBuffer)
+      return p.m_bufferDynamicOffset;
+  }
+  CHECK(false, ("Shaders parameters are not set."));
+  return 0;
+}
+
+VkSampler VulkanBaseContext::GetSampler(SamplerKey const & key)
+{
+  auto const it = m_samplers.find(key);
+  if (it != m_samplers.end())
+    return it->second;
+
+  VkSamplerCreateInfo samplerCreateInfo = {};
+  samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+  samplerCreateInfo.magFilter = samplerCreateInfo.minFilter = GetVulkanFilter(key.GetTextureFilter());
+  samplerCreateInfo.addressModeU = GetVulkanSamplerAddressMode(key.GetWrapSMode());
+  samplerCreateInfo.addressModeV = GetVulkanSamplerAddressMode(key.GetWrapTMode());
+
+  VkSampler sampler;
+  CHECK_VK_CALL(vkCreateSampler(m_device, &samplerCreateInfo, nullptr, &sampler));
+
+  m_samplers.insert(std::make_pair(key, sampler));
+  return sampler;
+}
 }  // namespace vulkan
 }  // namespace dp
diff --git a/drape/vulkan/vulkan_base_context.hpp b/drape/vulkan/vulkan_base_context.hpp
index b080ed4094..2d7563895c 100644
--- a/drape/vulkan/vulkan_base_context.hpp
+++ b/drape/vulkan/vulkan_base_context.hpp
@@ -17,6 +17,7 @@
 #include <array>
 #include <cstdint>
 #include <functional>
+#include <map>
 #include <vector>
 
 namespace dp
@@ -86,7 +87,11 @@ public:
 
   VkCommandBuffer GetCurrentCommandBuffer() const { return m_commandBuffer; }
   VkPipeline GetCurrentPipeline();
-  DescriptorSet GetCurrentDescriptorSet();
+  DescriptorSetGroup GetCurrentDescriptorSetGroup();
+  VkPipelineLayout GetCurrentPipelineLayout() const;
+  uint32_t GetCurrentDynamicBufferOffset() const;
+
+  VkSampler GetSampler(SamplerKey const & key);
 
   enum class HandlerType : uint8_t
   {
@@ -161,19 +166,10 @@ protected:
   std::array<std::vector<std::pair<uint32_t, ContextHandler>>,
              static_cast<size_t>(HandlerType::Count)> m_handlers;
 
-  bool m_depthEnabled = false;
-  bool m_stencilEnabled = false;
-  StencilFace m_stencilFunctionFace = {};
-  TestFunction m_stencilFunction = {};
-  TestFunction m_depthFunction = {};
-  StencilFace m_stencilActionFace = {};
-  StencilAction m_stencilFailAction = {};
-  StencilAction m_depthFailAction = {};
-  StencilAction m_passAction = {};
-  uint32_t m_stencilReferenceValue = 1;
-
-  ref_ptr<VulkanGpuProgram> m_currentProgram;
+  VulkanPipeline::PipelineKey m_pipelineKey;
   std::vector<ParamDescriptor> m_paramDescriptors;
+  uint32_t m_stencilReferenceValue = 1;
+  std::map<SamplerKey, VkSampler> m_samplers;
 };
 }  // namespace vulkan
 }  // namespace dp
diff --git a/drape/vulkan/vulkan_mesh_object_impl.cpp b/drape/vulkan/vulkan_mesh_object_impl.cpp
index 0b6ec6f32b..da184455d0 100644
--- a/drape/vulkan/vulkan_mesh_object_impl.cpp
+++ b/drape/vulkan/vulkan_mesh_object_impl.cpp
@@ -43,7 +43,9 @@ public:
     m_objectManager = vulkanContext->GetObjectManager();
     VkDevice device = vulkanContext->GetDevice();
 
+    ResetDescriptorSetGroup();
     m_pipeline = {};
+
     m_geometryBuffers.resize(m_mesh->m_buffers.size());
     m_bindingInfo.resize(m_mesh->m_buffers.size());
     for (size_t i = 0; i < m_mesh->m_buffers.size(); i++)
@@ -81,10 +83,12 @@ public:
 
   void Reset() override
   {
+    ResetDescriptorSetGroup();
+    m_pipeline = {};
+
     for (auto const & b : m_geometryBuffers)
       m_objectManager->DestroyObject(b);
     m_geometryBuffers.clear();
-    m_pipeline = {};
   }
 
   void UpdateBuffer(ref_ptr<dp::GraphicsContext> context, uint32_t bufferInd) override
@@ -164,6 +168,14 @@ public:
         return;
     }
 
+    if (!m_descriptorSetGroup)
+      m_descriptorSetGroup = vulkanContext->GetCurrentDescriptorSetGroup();
+
+    uint32_t dynamicOffset = vulkanContext->GetCurrentDynamicBufferOffset();
+    vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
+                            vulkanContext->GetCurrentPipelineLayout(), 0, 1,
+                            &m_descriptorSetGroup.m_descriptorSet, 1, &dynamicOffset);
+
     vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipeline);
 
     VkDeviceSize offsets[1] = {0};
@@ -179,11 +191,23 @@ public:
   void Unbind() override {}
 
 private:
+  void ResetDescriptorSetGroup()
+  {
+    if (!m_descriptorSetGroup)
+      return;
+
+    CHECK_VK_CALL(vkFreeDescriptorSets(m_objectManager->GetDevice(),
+                  m_descriptorSetGroup.m_descriptorPool, 1 /* count */,
+                  &m_descriptorSetGroup.m_descriptorSet));
+    m_descriptorSetGroup = {};
+  }
+
   ref_ptr<dp::MeshObject> m_mesh;
   ref_ptr<VulkanObjectManager> m_objectManager;
   std::vector<VulkanObject> m_geometryBuffers;
   std::vector<dp::BindingInfo> m_bindingInfo;
   VkPipeline m_pipeline = {};
+  DescriptorSetGroup m_descriptorSetGroup;
 };
 }  // namespace vulkan
 
diff --git a/drape/vulkan/vulkan_pipeline.cpp b/drape/vulkan/vulkan_pipeline.cpp
index 075849d761..7cc42d2f88 100644
--- a/drape/vulkan/vulkan_pipeline.cpp
+++ b/drape/vulkan/vulkan_pipeline.cpp
@@ -32,20 +32,6 @@ uint8_t constexpr kStencilFrontFailActionByte = 2;
 uint8_t constexpr kStencilFrontDepthFailActionByte = 1;
 uint8_t constexpr kStencilFrontPassActionByte = 0;
 
-template<typename T>
-void SetStateByte(T & state, uint8_t value, uint8_t byteNumber)
-{
-  auto const shift = byteNumber * 8;
-  auto const mask = ~(static_cast<T>(0xFF) << shift);
-  state = (state & mask) | (static_cast<T>(value) << shift);
-}
-
-template<typename T>
-uint8_t GetStateByte(T & state, uint8_t byteNumber)
-{
-  return static_cast<uint8_t>((state >> byteNumber * 8) & 0xFF);
-}
-
 VkCompareOp DecodeTestFunction(uint8_t testFunctionByte)
 {
   switch (static_cast<TestFunction>(testFunctionByte))
@@ -254,6 +240,8 @@ void VulkanPipeline::Destroy(VkDevice device)
 
 VkPipeline VulkanPipeline::GetPipeline(VkDevice device, PipelineKey const & key)
 {
+  CHECK(key.m_renderPass != VK_NULL_HANDLE, ());
+
   auto const it = m_pipelineCache.find(key);
   if (it != m_pipelineCache.end())
     return it->second;
@@ -499,19 +487,6 @@ bool VulkanPipeline::DepthStencilKey::operator!=(DepthStencilKey const & rhs) co
          m_depthFunction != rhs.m_depthFunction || m_stencil != rhs.m_stencil;
 }
 
-VulkanPipeline::PipelineKey::PipelineKey(VkRenderPass renderPass, ref_ptr<VulkanGpuProgram> program,
-                                         DepthStencilKey const & depthStencil,
-                                         std::vector<BindingInfo> && bindingInfo,
-                                         VkPrimitiveTopology primitiveTopology,
-                                         bool blendingEnabled)
-  : m_renderPass(renderPass)
-  , m_program(std::move(program))
-  , m_depthStencil(depthStencil)
-  , m_bindingInfo(std::move(bindingInfo))
-  , m_primitiveTopology(primitiveTopology)
-  , m_blendingEnabled(blendingEnabled)
-{}
-  
 bool VulkanPipeline::PipelineKey::operator<(PipelineKey const & rhs) const
 {
   if (m_renderPass != rhs.m_renderPass)
diff --git a/drape/vulkan/vulkan_pipeline.hpp b/drape/vulkan/vulkan_pipeline.hpp
index 635a2109dd..7db9f3266e 100644
--- a/drape/vulkan/vulkan_pipeline.hpp
+++ b/drape/vulkan/vulkan_pipeline.hpp
@@ -38,10 +38,6 @@ public:
 
   struct PipelineKey
   {
-    PipelineKey() = default;
-    PipelineKey(VkRenderPass renderPass, ref_ptr<VulkanGpuProgram> program,
-                DepthStencilKey const & depthStencil, std::vector<BindingInfo> && bindingInfo,
-                VkPrimitiveTopology primitiveTopology, bool blendingEnabled);
     bool operator<(PipelineKey const & rhs) const;
 
     VkRenderPass m_renderPass = {};
diff --git a/drape/vulkan/vulkan_texture.cpp b/drape/vulkan/vulkan_texture.cpp
index c1847811b4..79ac2937d7 100644
--- a/drape/vulkan/vulkan_texture.cpp
+++ b/drape/vulkan/vulkan_texture.cpp
@@ -1,7 +1,6 @@
 #include "drape/vulkan/vulkan_texture.hpp"
 #include "drape/vulkan/vulkan_base_context.hpp"
 #include "drape/vulkan/vulkan_staging_buffer.hpp"
-#include "drape/vulkan/vulkan_utils.hpp"
 
 #include "base/logging.hpp"
 
@@ -249,7 +248,13 @@ void VulkanTexture::SetFilter(TextureFilter filter)
 
 bool VulkanTexture::Validate() const
 {
-  return m_textureObject.m_image != 0 && m_textureObject.m_imageView != 0;
+  return m_textureObject.m_image != VK_NULL_HANDLE &&
+         m_textureObject.m_imageView != VK_NULL_HANDLE;
+}
+
+SamplerKey VulkanTexture::GetSamplerKey() const
+{
+  return SamplerKey(m_params.m_filter, m_params.m_wrapSMode, m_params.m_wrapTMode);
 }
 }  // namespace vulkan
 }  // namespace dp
diff --git a/drape/vulkan/vulkan_texture.hpp b/drape/vulkan/vulkan_texture.hpp
index 10d91ac2eb..67ec165674 100644
--- a/drape/vulkan/vulkan_texture.hpp
+++ b/drape/vulkan/vulkan_texture.hpp
@@ -3,6 +3,7 @@
 #include "drape/hw_texture.hpp"
 #include "drape/pointers.hpp"
 #include "drape/vulkan/vulkan_object_manager.hpp"
+#include "drape/vulkan/vulkan_utils.hpp"
 
 #include <vulkan_wrapper.h>
 #include <vulkan/vulkan.h>
@@ -38,6 +39,7 @@ public:
   bool Validate() const override;
 
   VkImageView GetTextureView() const { return m_textureObject.m_imageView; }
+  SamplerKey GetSamplerKey() const;
   
 private:
   ref_ptr<VulkanTextureAllocator> m_allocator;
diff --git a/drape/vulkan/vulkan_utils.cpp b/drape/vulkan/vulkan_utils.cpp
index ce7a36594a..63ec23cb37 100644
--- a/drape/vulkan/vulkan_utils.cpp
+++ b/drape/vulkan/vulkan_utils.cpp
@@ -4,6 +4,15 @@ namespace dp
 {
 namespace vulkan
 {
+namespace
+{
+// Sampler package.
+uint8_t constexpr kWrapSModeByte = 3;
+uint8_t constexpr kWrapTModeByte = 2;
+uint8_t constexpr kMagFilterByte = 1;
+uint8_t constexpr kMinFilterByte = 0;
+}  // namespace
+
 std::string GetVulkanResultString(VkResult result)
 {
   switch (result)
@@ -45,5 +54,58 @@ std::string GetVulkanResultString(VkResult result)
   UNREACHABLE();
   return "Unknown result";
 }
+
+SamplerKey::SamplerKey(TextureFilter filter, TextureWrapping wrapSMode, TextureWrapping wrapTMode)
+{
+  Set(filter, wrapSMode, wrapTMode);
+}
+
+void SamplerKey::Set(TextureFilter filter, TextureWrapping wrapSMode, TextureWrapping wrapTMode)
+{
+  SetStateByte(m_sampler, static_cast<uint8_t>(filter), kMinFilterByte);
+  SetStateByte(m_sampler, static_cast<uint8_t>(filter), kMagFilterByte);
+  SetStateByte(m_sampler, static_cast<uint8_t>(wrapSMode), kWrapSModeByte);
+  SetStateByte(m_sampler, static_cast<uint8_t>(wrapTMode), kWrapTModeByte);
+}
+
+TextureFilter SamplerKey::GetTextureFilter() const
+{
+  return static_cast<TextureFilter>(GetStateByte(m_sampler, kMinFilterByte));
+}
+
+TextureWrapping SamplerKey::GetWrapSMode() const
+{
+  return static_cast<TextureWrapping>(GetStateByte(m_sampler, kWrapSModeByte));
+}
+
+TextureWrapping SamplerKey::GetWrapTMode() const
+{
+  return static_cast<TextureWrapping>(GetStateByte(m_sampler, kWrapTModeByte));
+}
+
+bool SamplerKey::operator<(SamplerKey const & rhs) const
+{
+  return m_sampler < rhs.m_sampler;
+}
+
+VkSamplerAddressMode GetVulkanSamplerAddressMode(TextureWrapping wrapping)
+{
+  switch (wrapping)
+  {
+  case TextureWrapping::ClampToEdge: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+  case TextureWrapping::Repeat: return VK_SAMPLER_ADDRESS_MODE_REPEAT;
+  }
+  UNREACHABLE();
+}
+
+VkFilter GetVulkanFilter(TextureFilter filter)
+{
+  switch (filter)
+  {
+  case TextureFilter::Linear: return VK_FILTER_LINEAR;
+  case TextureFilter::Nearest: return VK_FILTER_NEAREST;
+  }
+  UNREACHABLE();
+}
 }  // namespace vulkan
 }  // namespace dp
diff --git a/drape/vulkan/vulkan_utils.hpp b/drape/vulkan/vulkan_utils.hpp
index b80be21119..d27d4f6468 100644
--- a/drape/vulkan/vulkan_utils.hpp
+++ b/drape/vulkan/vulkan_utils.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "drape/texture_types.hpp"
+
 #include "base/assert.hpp"
 #include "base/logging.hpp"
 
@@ -31,11 +33,47 @@ struct ParamDescriptor
   int8_t m_textureSlot = 0;
 };
 
-struct DescriptorSet
+struct DescriptorSetGroup
 {
   VkDescriptorSet m_descriptorSet = {};
   VkDescriptorPool m_descriptorPool = {};
+
+  explicit operator bool()
+  {
+    return m_descriptorSet != VK_NULL_HANDLE &&
+           m_descriptorPool != VK_NULL_HANDLE;
+  }
+};
+
+template<typename T>
+void SetStateByte(T & state, uint8_t value, uint8_t byteNumber)
+{
+  auto const shift = byteNumber * 8;
+  auto const mask = ~(static_cast<T>(0xFF) << shift);
+  state = (state & mask) | (static_cast<T>(value) << shift);
+}
+
+template<typename T>
+uint8_t GetStateByte(T & state, uint8_t byteNumber)
+{
+  return static_cast<uint8_t>((state >> byteNumber * 8) & 0xFF);
+}
+
+struct SamplerKey
+{
+  SamplerKey() = default;
+  SamplerKey(TextureFilter filter, TextureWrapping wrapSMode, TextureWrapping wrapTMode);
+  void Set(TextureFilter filter, TextureWrapping wrapSMode, TextureWrapping wrapTMode);
+  TextureFilter GetTextureFilter() const;
+  TextureWrapping GetWrapSMode() const;
+  TextureWrapping GetWrapTMode() const;
+  bool operator<(SamplerKey const & rhs) const;
+
+  uint32_t m_sampler = 0;
 };
+
+extern VkSamplerAddressMode GetVulkanSamplerAddressMode(TextureWrapping wrapping);
+extern VkFilter GetVulkanFilter(TextureFilter filter);
 }  // namespace vulkan
 }  // namespace dp
 
diff --git a/drape/vulkan/vulkan_vertex_array_buffer_impl.cpp b/drape/vulkan/vulkan_vertex_array_buffer_impl.cpp
index a08b418ef2..8dd87d2ac5 100644
--- a/drape/vulkan/vulkan_vertex_array_buffer_impl.cpp
+++ b/drape/vulkan/vulkan_vertex_array_buffer_impl.cpp
@@ -2,6 +2,7 @@
 #include "drape/vertex_array_buffer.hpp"
 #include "drape/vulkan/vulkan_base_context.hpp"
 #include "drape/vulkan/vulkan_gpu_buffer_impl.hpp"
+#include "drape/vulkan/vulkan_utils.hpp"
 
 #include "base/assert.hpp"
 #include "base/macros.hpp"
@@ -77,6 +78,14 @@ public:
         return;
     }
 
+    if (!m_descriptorSetGroup)
+      m_descriptorSetGroup = vulkanContext->GetCurrentDescriptorSetGroup();
+
+    uint32_t dynamicOffset = vulkanContext->GetCurrentDynamicBufferOffset();
+    vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
+                            vulkanContext->GetCurrentPipelineLayout(), 0, 1,
+                            &m_descriptorSetGroup.m_descriptorSet, 1, &dynamicOffset);
+
     vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipeline);
 
     VkDeviceSize offsets[1] = {0};
@@ -111,6 +120,7 @@ private:
   std::vector<dp::BindingInfo> m_bindingInfo;
   VkPipeline m_pipeline = {};
   bool m_lastDrawAsLine = false;
+  DescriptorSetGroup m_descriptorSetGroup;
 };
 }  // namespace vulkan