diff --git a/Ray.cpp b/Ray.cpp
index e6e3a148..1a68704b 100644
--- a/Ray.cpp
+++ b/Ray.cpp
@@ -34,7 +34,7 @@
 #endif // ENABLE_VK_IMPL
 
 #if !(defined(ENABLE_DX_IMPL) && defined(_WIN32)) && !defined(ENABLE_VK_IMPL)
-#pragma message("Compiling without GPU support")
+#pragma message("Ray: Compiling without GPU support")
 #endif
 
 #include "internal/simd/detect.h"
diff --git a/internal/Vk/ContextVK.cpp b/internal/Vk/ContextVK.cpp
index 073a672a..7418a0ef 100644
--- a/internal/Vk/ContextVK.cpp
+++ b/internal/Vk/ContextVK.cpp
@@ -261,9 +261,9 @@ bool Ray::Vk::Context::Init(ILog *log, const char *preferred_device, const int v
 
     for (int i = 0; i < MaxFramesInFlight; ++i) {
         const int PoolStep = 8;
+        const int MaxImgSamplerCount = 16;
         const int MaxImgCount = 16;
         const int MaxSamplerCount = 16;
-        const int MaxImgSamplerCount = 16;
         const int MaxStoreImgCount = 6;
         const int MaxUBufCount = 8;
         const int MaxSBufCount = 20;
@@ -272,7 +272,7 @@ bool Ray::Vk::Context::Init(ILog *log, const char *preferred_device, const int v
         const int InitialSetsCount = 16;
 
         default_descr_alloc_[i] = std::make_unique<DescrMultiPoolAlloc>(
-            this, PoolStep, MaxImgCount, MaxSamplerCount, MaxImgSamplerCount, MaxStoreImgCount, MaxUBufCount,
+            this, PoolStep, MaxImgSamplerCount, MaxImgCount, MaxSamplerCount, MaxStoreImgCount, MaxUBufCount,
             MaxSBufCount, MaxTBufCount, MaxAccCount, InitialSetsCount);
     }
 
diff --git a/internal/Vk/DescriptorPoolVK.cpp b/internal/Vk/DescriptorPoolVK.cpp
index 64bca652..728a0be3 100644
--- a/internal/Vk/DescriptorPoolVK.cpp
+++ b/internal/Vk/DescriptorPoolVK.cpp
@@ -6,9 +6,9 @@
 namespace Ray {
 namespace Vk {
 const VkDescriptorType g_descr_types_vk[] = {
+    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,    // CombinedImageSampler
     VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,             // SampledImage
     VK_DESCRIPTOR_TYPE_SAMPLER,                   // Sampler
-    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,    // CombinedImageSampler
     VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,             // StorageImage
     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,            // UniformBuffer
     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,            // StorageBuffer
@@ -40,9 +40,9 @@ Ray::Vk::DescrPool &Ray::Vk::DescrPool::operator=(DescrPool &&rhs) noexcept {
 bool Ray::Vk::DescrPool::Init(const DescrSizes &sizes, const uint32_t sets_count) {
     Destroy();
 
+    descr_counts_[int(eDescrType::CombinedImageSampler)] = sizes.img_sampler_count;
     descr_counts_[int(eDescrType::SampledImage)] = sizes.img_count;
     descr_counts_[int(eDescrType::Sampler)] = sizes.sampler_count;
-    descr_counts_[int(eDescrType::CombinedImageSampler)] = sizes.img_sampler_count;
     descr_counts_[int(eDescrType::StorageImage)] = sizes.store_img_count;
     descr_counts_[int(eDescrType::UniformBuffer)] = sizes.ubuf_count;
     descr_counts_[int(eDescrType::StorageBuffer)] = sizes.sbuf_count;
@@ -138,29 +138,29 @@ bool Ray::Vk::DescrPoolAlloc::Reset() {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
-Ray::Vk::DescrMultiPoolAlloc::DescrMultiPoolAlloc(Context *ctx, const uint32_t pool_step, const uint32_t max_img_count,
-                                                  const uint32_t max_sampler_count,
-                                                  const uint32_t max_img_sampler_count,
-                                                  const uint32_t max_store_img_count, const uint32_t max_ubuf_count,
-                                                  const uint32_t max_sbuf_count, const uint32_t max_tbuf_count,
-                                                  const uint32_t max_acc_count, const uint32_t initial_sets_count)
+Ray::Vk::DescrMultiPoolAlloc::DescrMultiPoolAlloc(Context *ctx, const uint32_t pool_step,
+                                                  const uint32_t max_img_sampler_count, const uint32_t max_img_count,
+                                                  const uint32_t max_sampler_count, const uint32_t max_store_img_count,
+                                                  const uint32_t max_ubuf_count, const uint32_t max_sbuf_count,
+                                                  const uint32_t max_tbuf_count, const uint32_t max_acc_count,
+                                                  const uint32_t initial_sets_count)
     : pool_step_(pool_step) {
+    img_sampler_based_count_ = (max_img_sampler_count + pool_step - 1) / pool_step;
     img_based_count_ = (max_img_count + pool_step - 1) / pool_step;
     sampler_based_count_ = (max_sampler_count + pool_step - 1) / pool_step;
-    img_sampler_based_count_ = (max_img_sampler_count + pool_step - 1) / pool_step;
     store_img_based_count_ = (max_store_img_count + pool_step - 1) / pool_step;
     ubuf_based_count_ = (max_ubuf_count + pool_step - 1) / pool_step;
     sbuf_based_count_ = (max_sbuf_count + pool_step - 1) / pool_step;
     tbuf_based_count_ = (max_tbuf_count + pool_step - 1) / pool_step;
     acc_based_count_ = (max_acc_count + pool_step - 1) / pool_step;
-    const uint32_t required_pools_count = img_based_count_ * sampler_based_count_ * img_sampler_based_count_ *
+    const uint32_t required_pools_count = img_sampler_based_count_ * img_based_count_ * sampler_based_count_ *
                                           store_img_based_count_ * ubuf_based_count_ * sbuf_based_count_ *
                                           tbuf_based_count_ * acc_based_count_;
 
     // store rounded values
-    max_sampled_img_count_ = pool_step * img_based_count_;
-    max_sampler_count_ = pool_step * sampler_based_count_;
     max_img_sampler_count_ = pool_step * img_sampler_based_count_;
+    max_img_count_ = pool_step * img_based_count_;
+    max_sampler_count_ = pool_step * sampler_based_count_;
     max_store_img_count_ = pool_step * store_img_based_count_;
     max_ubuf_count_ = pool_step * ubuf_based_count_;
     max_sbuf_count_ = pool_step * sbuf_based_count_;
@@ -195,13 +195,13 @@ Ray::Vk::DescrMultiPoolAlloc::DescrMultiPoolAlloc(Context *ctx, const uint32_t p
 
 VkDescriptorSet Ray::Vk::DescrMultiPoolAlloc::Alloc(const DescrSizes &sizes, const VkDescriptorSetLayout layout) {
     assert(sizes.acc_count <= max_acc_count_);
-    assert(sizes.img_count <= max_sampled_img_count_);
-    assert(sizes.sampler_count <= max_sampler_count_);
-    assert(sizes.img_sampler_count <= max_img_sampler_count_);
-    assert(sizes.sbuf_count <= max_sbuf_count_);
-    assert(sizes.store_img_count <= max_store_img_count_);
     assert(sizes.tbuf_count <= max_tbuf_count_);
+    assert(sizes.sbuf_count <= max_sbuf_count_);
     assert(sizes.ubuf_count <= max_ubuf_count_);
+    assert(sizes.store_img_count <= max_store_img_count_);
+    assert(sizes.sampler_count <= max_sampler_count_);
+    assert(sizes.img_count <= max_img_count_);
+    assert(sizes.img_sampler_count <= max_img_sampler_count_);
 
     const uint32_t img_sampler_based_index =
         sizes.img_sampler_count ? ((sizes.img_sampler_count + pool_step_ - 1) / pool_step_ - 1) : 0;
diff --git a/internal/Vk/DescriptorPoolVK.h b/internal/Vk/DescriptorPoolVK.h
index 57fd18af..7e649544 100644
--- a/internal/Vk/DescriptorPoolVK.h
+++ b/internal/Vk/DescriptorPoolVK.h
@@ -8,9 +8,9 @@ namespace Vk {
 class Context;
 
 enum class eDescrType : uint8_t {
+    CombinedImageSampler,
     SampledImage,
     Sampler,
-    CombinedImageSampler,
     StorageImage,
     UniformBuffer,
     StorageBuffer,
@@ -20,9 +20,9 @@ enum class eDescrType : uint8_t {
 };
 
 struct DescrSizes {
+    uint32_t img_sampler_count = 0;
     uint32_t img_count = 0;
     uint32_t sampler_count = 0;
-    uint32_t img_sampler_count = 0;
     uint32_t store_img_count = 0;
     uint32_t ubuf_count = 0;
     uint32_t sbuf_count = 0;
@@ -87,15 +87,15 @@ class DescrPoolAlloc {
 //
 class DescrMultiPoolAlloc {
     uint32_t pool_step_ = 0;
-    uint32_t img_based_count_ = 0, sampler_based_count_ = 0, img_sampler_based_count_ = 0, store_img_based_count_ = 0,
+    uint32_t img_sampler_based_count_ = 0, img_based_count_ = 0, sampler_based_count_ = 0, store_img_based_count_ = 0,
              ubuf_based_count_ = 0, sbuf_based_count_ = 0, tbuf_based_count_ = 0, acc_based_count_;
-    uint32_t max_sampled_img_count_ = 0, max_sampler_count_ = 0, max_img_sampler_count_ = 0, max_store_img_count_ = 0,
+    uint32_t max_img_sampler_count_ = 0, max_img_count_ = 0, max_sampler_count_ = 0, max_store_img_count_ = 0,
              max_ubuf_count_ = 0, max_sbuf_count_ = 0, max_tbuf_count_ = 0, max_acc_count_ = 0;
     SmallVector<DescrPoolAlloc, 16> pools_;
 
   public:
-    DescrMultiPoolAlloc(Context *ctx, uint32_t pool_step, uint32_t max_img_count, uint32_t max_sampler_count,
-                        uint32_t max_img_sampler_count, uint32_t max_store_img_count, uint32_t max_ubuf_count,
+    DescrMultiPoolAlloc(Context *ctx, uint32_t pool_step, uint32_t max_img_sampler_count, uint32_t max_img_count,
+                        uint32_t max_sampler_count, uint32_t max_store_img_count, uint32_t max_ubuf_count,
                         uint32_t max_sbuf_count, uint32_t max_tbuf_count, uint32_t max_acc_count,
                         uint32_t initial_sets_count);
 
diff --git a/internal/Vk/DrawCallVK.cpp b/internal/Vk/DrawCallVK.cpp
index dd9fc333..aeb3516f 100644
--- a/internal/Vk/DrawCallVK.cpp
+++ b/internal/Vk/DrawCallVK.cpp
@@ -12,7 +12,6 @@
 VkDescriptorSet Ray::Vk::PrepareDescriptorSet(Context *ctx, VkDescriptorSetLayout layout, Span<const Binding> bindings,
                                               DescrMultiPoolAlloc *descr_alloc, ILog *log) {
     VkDescriptorImageInfo sampler_infos[16] = {};
-    // VkDescriptorImageInfo sampled_img_infos[16] = {};
     VkDescriptorImageInfo img_sampler_infos[16] = {};
     VkDescriptorImageInfo img_storage_infos[16] = {};
     VkDescriptorBufferInfo ubuf_infos[16] = {};