Added buffer view initialization

7 files changed, 199 insertions, 88 deletions

diff --git a/Graphics/GraphicsEngineVulkan/include/BufferVkImpl.h b/Graphics/GraphicsEngineVulkan/include/BufferVkImpl.h
index ba94b7b9..2b70c416 100644
--- a/Graphics/GraphicsEngineVulkan/include/BufferVkImpl.h
+++ b/Graphics/GraphicsEngineVulkan/include/BufferVkImpl.h
@@ -122,9 +122,7 @@ public:
 private:
     virtual void CreateViewInternal( const struct BufferViewDesc &ViewDesc, IBufferView **ppView, bool bIsDefaultView )override;
 
-    VkBufferView CreateUAV(struct BufferViewDesc &UAVDesc);
-    VkBufferView CreateSRV(struct BufferViewDesc &SRVDesc);
-    VkBufferView CreateCBV(struct BufferViewDesc &CBVDesc);
+    VkBufferView CreateView(struct BufferViewDesc &ViewDesc);
     /*    DescriptorHeapAllocation m_CBVDescriptorAllocation;
 
 #ifdef _DEBUG
diff --git a/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.h b/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.h
index b2be3781..d46806ae 100644
--- a/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.h
+++ b/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.h
@@ -109,7 +109,7 @@ public:
     
 
     std::shared_ptr<VulkanUtilities::VulkanInstance> GetVulkanInstance(){return m_VulkanInstance;}
-    VulkanUtilities::VulkanPhysicalDevice &GetPhysicalDevice(){return *m_PhysicalDevice;}
+    const VulkanUtilities::VulkanPhysicalDevice &GetPhysicalDevice(){return *m_PhysicalDevice;}
     VkDevice GetVkDevice()const{return m_VkDevice;}
 
 private:
diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.h b/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.h
index 76739fb1..3542f33e 100644
--- a/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.h
+++ b/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.h
@@ -34,6 +34,8 @@ namespace Diligent
 VkFormat TexFormatToVkFormat(TEXTURE_FORMAT TexFmt);
 TEXTURE_FORMAT VkFormatToTexFormat(VkFormat VkFmt);
 
+VkFormat TypeToVkFormat(VALUE_TYPE ValType, Uint32 NumComponents, Bool bIsNormalized);
+
 #if 0
 D3D12_COMPARISON_FUNC ComparisonFuncToD3D12ComparisonFunc(COMPARISON_FUNCTION Func);
 D3D12_FILTER FilterTypeToD3D12Filter(FILTER_TYPE MinFilter, FILTER_TYPE MagFilter, FILTER_TYPE MipFilter);
diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanPhysicalDevice.h b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanPhysicalDevice.h
index 8b592720..b64ce488 100644
--- a/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanPhysicalDevice.h
+++ b/Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanPhysicalDevice.h
@@ -32,13 +32,13 @@ namespace VulkanUtilities
     {
     public:
         VulkanPhysicalDevice(VkPhysicalDevice vkDevice);
-        uint32_t FindQueueFamily(VkQueueFlags QueueFlags);
+        uint32_t FindQueueFamily(VkQueueFlags QueueFlags)const;
         VkPhysicalDevice GetVkDeviceHandle()const{return m_VkDevice;}
-        bool IsExtensionSupported(const char *ExtensionName);
+        bool IsExtensionSupported(const char *ExtensionName)const;
         bool CheckPresentSupport(uint32_t queueFamilyIndex, VkSurfaceKHR VkSurface)const;
         
         static constexpr uint32_t InvalidMemoryTypeIndex = static_cast<uint32_t>(-1);
-        uint32_t GetMemoryTypeIndex(uint32_t typeBits, VkMemoryPropertyFlags properties);
+        uint32_t GetMemoryTypeIndex(uint32_t typeBits, VkMemoryPropertyFlags properties)const;
 
     private:
         const VkPhysicalDevice m_VkDevice;
diff --git a/Graphics/GraphicsEngineVulkan/src/BufferVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/BufferVkImpl.cpp
index 5b6fddf4..a99afd71 100644
--- a/Graphics/GraphicsEngineVulkan/src/BufferVkImpl.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/BufferVkImpl.cpp
@@ -25,7 +25,7 @@
 #include "BufferVkImpl.h"
 #include "RenderDeviceVkImpl.h"
 #include "DeviceContextVkImpl.h"
-//#include "VulkanTypeConversions.h"
+#include "VulkanTypeConversions.h"
 #include "BufferViewVkImpl.h"
 #include "GraphicsAccessories.h"
 #include "EngineMemory.h"
@@ -67,6 +67,7 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters,
         }
     }
 
+    auto vkAllocator = pRenderDeviceVk->GetVulkanInstance()->GetVkAllocator();
     if(m_Desc.Usage == USAGE_DYNAMIC && (m_Desc.BindFlags & (BIND_SHADER_RESOURCE|BIND_UNORDERED_ACCESS)) == 0)
     {
         UNSUPPORTED("Dynamic buffers are not yet implemented");
@@ -89,9 +90,9 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters,
             VK_BUFFER_USAGE_TRANSFER_SRC_BIT | // The buffer can be used as the source of a transfer command 
             VK_BUFFER_USAGE_TRANSFER_DST_BIT;  // The buffer can be used as the destination of a transfer command
         if (m_Desc.BindFlags & BIND_UNORDERED_ACCESS)
-            VkBuffCI.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; // | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
+            VkBuffCI.usage |= m_Desc.Mode == BUFFER_MODE_FORMATTED ? VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT : VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
         if (m_Desc.BindFlags & BIND_SHADER_RESOURCE)
-            VkBuffCI.usage |= VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER | VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+            VkBuffCI.usage |= m_Desc.Mode == BUFFER_MODE_FORMATTED ? VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER : VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
         if (m_Desc.BindFlags & BIND_VERTEX_BUFFER)
             VkBuffCI.usage |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
         if (m_Desc.BindFlags & BIND_INDEX_BUFFER)
@@ -99,7 +100,7 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters,
         if (m_Desc.BindFlags & BIND_INDIRECT_DRAW_ARGS)
             VkBuffCI.usage |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
         if (m_Desc.BindFlags & BIND_UNIFORM_BUFFER)
-            VkBuffCI.usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; // | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
+            VkBuffCI.usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
 
         VkBuffCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE; // sharing mode of the buffer when it will be accessed by multiple queue families.
         VkBuffCI.queueFamilyIndexCount = 0; // number of entries in the pQueueFamilyIndices array
@@ -107,7 +108,7 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters,
                                                 // (ignored if sharingMode is not VK_SHARING_MODE_CONCURRENT).
 
         auto vkDevice = pRenderDeviceVk->GetVkDevice();
-        auto err = vkCreateBuffer(vkDevice, &VkBuffCI, nullptr, &m_VkBuffer);
+        auto err = vkCreateBuffer(vkDevice, &VkBuffCI, vkAllocator, &m_VkBuffer);
         CHECK_VK_ERROR_AND_THROW(err, "Failed to create Vulkan buffer object");
 
         VkMemoryRequirements MemReqs = {};
@@ -143,7 +144,7 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters,
             LOG_ERROR_AND_THROW("Failed to find suitable device memory type for a buffer");
         }
 
-        err = vkAllocateMemory(vkDevice, &MemAlloc, nullptr, &m_BufferMemory);
+        err = vkAllocateMemory(vkDevice, &MemAlloc, vkAllocator, &m_BufferMemory);
         CHECK_VK_ERROR_AND_THROW(err, "Failed to allocate device local memory for a Vulkan buffer object");
 
         err = vkBindBufferMemory(vkDevice, m_VkBuffer, m_BufferMemory, 0 /*offset*/);
@@ -162,7 +163,7 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters,
             VkStaginBuffCI.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
 
             VkBuffer vkStagingBuffer = VK_NULL_HANDLE;
-            err = vkCreateBuffer(vkDevice, &VkStaginBuffCI, nullptr, &vkStagingBuffer);
+            err = vkCreateBuffer(vkDevice, &VkStaginBuffCI, vkAllocator, &vkStagingBuffer);
             CHECK_VK_ERROR_AND_THROW(err, "Failed to create staging buffer");
 
             VulkanUtilities::SetBufferName(vkDevice, vkStagingBuffer, "Staging buffer");
@@ -187,7 +188,7 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters,
                    "and the VK_MEMORY_PROPERTY_HOST_COHERENT_BIT bit set(11.6)");
 
             VkDeviceMemory vkStagingBufferMemory = VK_NULL_HANDLE;
-            err = vkAllocateMemory(vkDevice, &StagingMemAlloc, nullptr, &vkStagingBufferMemory);
+            err = vkAllocateMemory(vkDevice, &StagingMemAlloc, vkAllocator, &vkStagingBufferMemory);
             CHECK_VK_ERROR_AND_THROW(err, "Failed to allocate memory for a staging buffer object");
 
             {
@@ -204,32 +205,7 @@ BufferVkImpl :: BufferVkImpl(IReferenceCounters *pRefCounters,
             
             err = vkBindBufferMemory(vkDevice, vkStagingBuffer, vkStagingBufferMemory, 0 /*offset*/);
             CHECK_VK_ERROR_AND_THROW(err, "Failed to bind staging bufer memory");
-
-
-
 #if 0
-            Vk_HEAP_PROPERTIES UploadHeapProps;
-	        UploadHeapProps.Type = Vk_HEAP_TYPE_UPLOAD;
-	        UploadHeapProps.CPUPageProperty = Vk_CPU_PAGE_PROPERTY_UNKNOWN;
-	        UploadHeapProps.MemoryPoolPreference = Vk_MEMORY_POOL_UNKNOWN;
-	        UploadHeapProps.CreationNodeMask = 1;
-	        UploadHeapProps.VisibleNodeMask = 1;
-
-            VkBuffDesc.Flags = Vk_RESOURCE_FLAG_NONE;
-            CComPtr<IVkResource> UploadBuffer;
-            hr = pVkDevice->CreateCommittedResource( &UploadHeapProps, Vk_HEAP_FLAG_NONE,
-		                &VkBuffDesc, Vk_RESOURCE_STATE_GENERIC_READ, nullptr,  __uuidof(UploadBuffer), 
-                        reinterpret_cast<void**>(static_cast<IVkResource**>(&UploadBuffer)) );
-            if(FAILED(hr))
-                LOG_ERROR_AND_THROW("Failed to create uload buffer");
-
-	        void* DestAddress = nullptr;
-	        hr = UploadBuffer->Map(0, nullptr, &DestAddress);
-            if(FAILED(hr))
-                LOG_ERROR_AND_THROW("Failed to map uload buffer");
-	        memcpy(DestAddress, BuffData.pData, BuffData.DataSize);
-	        UploadBuffer->Unmap(0, nullptr);
-
             auto  *pInitContext = pRenderDeviceVk->AllocateCommandContext();
 	        // copy data to the intermediate upload heap and then schedule a copy from the upload heap to the default buffer
             VERIFY_EXPR(m_UsageState == Vk_RESOURCE_STATE_COPY_DEST);
@@ -491,17 +467,11 @@ void BufferVkImpl::CreateViewInternal( const BufferViewDesc &OrigViewDesc, IBuff
         VERIFY( &BuffViewAllocator == &m_dbgBuffViewAllocator, "Buff view allocator does not match allocator provided at buffer initialization" );
 
         BufferViewDesc ViewDesc = OrigViewDesc;
-        if( ViewDesc.ViewType == BUFFER_VIEW_UNORDERED_ACCESS )
-        {
-            auto UAV = CreateUAV(ViewDesc);
-            *ppView = NEW_RC_OBJ(BuffViewAllocator, "BufferViewVkImpl instance", BufferViewVkImpl, bIsDefaultView ? this : nullptr)
-                                (GetDevice(), ViewDesc, this, UAV, bIsDefaultView );
-        }
-        else if( ViewDesc.ViewType == BUFFER_VIEW_SHADER_RESOURCE )
+        if( ViewDesc.ViewType == BUFFER_VIEW_UNORDERED_ACCESS || ViewDesc.ViewType == BUFFER_VIEW_SHADER_RESOURCE )
         {
-            auto SRV = CreateSRV(ViewDesc);
+            auto vkView = CreateView(ViewDesc);
             *ppView = NEW_RC_OBJ(BuffViewAllocator, "BufferViewVkImpl instance", BufferViewVkImpl, bIsDefaultView ? this : nullptr)
-                                (GetDevice(), ViewDesc, this, SRV, bIsDefaultView );
+                                (GetDevice(), ViewDesc, this, vkView, bIsDefaultView );
         }
 
         if( !bIsDefaultView && *ppView )
@@ -515,43 +485,29 @@ void BufferVkImpl::CreateViewInternal( const BufferViewDesc &OrigViewDesc, IBuff
 }
 
 
-VkBufferView BufferVkImpl::CreateUAV(BufferViewDesc &UAVDesc)
-{
-    CorrectBufferViewDesc( UAVDesc );
-#if 0
-    Vk_UNORDERED_ACCESS_VIEW_DESC Vk_UAVDesc;
-    BufferViewDesc_to_Vk_UAV_DESC(m_Desc, UAVDesc, Vk_UAVDesc);
-
-    auto *pDeviceVk = static_cast<RenderDeviceVkImpl*>(GetDevice())->GetVkDevice();
-    pDeviceVk->CreateUnorderedAccessView( m_pVkResource, nullptr, &Vk_UAVDesc, UAVDescriptor );
-#endif
-    return VK_NULL_HANDLE;
-}
-
-VkBufferView BufferVkImpl::CreateSRV(BufferViewDesc &SRVDesc)
-{
-    CorrectBufferViewDesc( SRVDesc );
-#if 0
-    Vk_SHADER_RESOURCE_VIEW_DESC Vk_SRVDesc;
-    BufferViewDesc_to_Vk_SRV_DESC(m_Desc, SRVDesc, Vk_SRVDesc);
-
-    auto *pDeviceVk = static_cast<RenderDeviceVkImpl*>(GetDevice())->GetVkDevice();
-    pDeviceVk->CreateShaderResourceView( m_pVkResource, &Vk_SRVDesc, SRVDescriptor );
-#endif
-    return VK_NULL_HANDLE;
-}
-
-VkBufferView BufferVkImpl::CreateCBV(BufferViewDesc &CBVDesc)
+VkBufferView BufferVkImpl::CreateView(struct BufferViewDesc &ViewDesc)
 {
-#if 0
-    Vk_CONSTANT_BUFFER_VIEW_DESC Vk_CBVDesc;
-    Vk_CBVDesc.BufferLocation = m_pVkResource->GetGPUVirtualAddress();
-    Vk_CBVDesc.SizeInBytes = m_Desc.uiSizeInBytes;
-
-    auto *pDeviceVk = static_cast<RenderDeviceVkImpl*>(GetDevice())->GetVkDevice();
-    pDeviceVk->CreateConstantBufferView( &Vk_CBVDesc, CBVDescriptor );
-#endif
-    return VK_NULL_HANDLE;
+    VkBufferView vkBuffView = VK_NULL_HANDLE;
+    CorrectBufferViewDesc(ViewDesc);
+    if( (ViewDesc.ViewType == BUFFER_VIEW_SHADER_RESOURCE || ViewDesc.ViewType == BUFFER_VIEW_UNORDERED_ACCESS) && 
+        m_Desc.Mode == BUFFER_MODE_FORMATTED)
+    {
+        VkBufferViewCreateInfo ViewCI = {};
+        ViewCI.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+        ViewCI.pNext = nullptr;
+        ViewCI.flags = 0; // reserved for future use
+        ViewCI.buffer = m_VkBuffer;
+        ViewCI.format = TypeToVkFormat(m_Desc.Format.ValueType, m_Desc.Format.NumComponents, m_Desc.Format.IsNormalized);
+        ViewCI.offset = ViewDesc.ByteOffset;
+        ViewCI.range = ViewDesc.ByteWidth; // size in bytes of the buffer view
+
+        auto *pDeviceVkImpl = static_cast<RenderDeviceVkImpl*>(GetDevice());
+        auto vkAllocator = pDeviceVkImpl->GetVulkanInstance()->GetVkAllocator();
+        auto vkDevice = pDeviceVkImpl->GetVkDevice();
+        auto err = vkCreateBufferView(vkDevice, &ViewCI, vkAllocator, &vkBuffView);
+        CHECK_VK_ERROR_AND_THROW(err, "Failed to create Vulkan buffer view");
+    }
+    return vkBuffView;
 }
 
 #if 0
diff --git a/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp b/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
index e5d7177f..e70e2f77 100644
--- a/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
@@ -458,6 +458,161 @@ TEXTURE_FORMAT VkFormatToTexFormat(VkFormat VkFmt)
 
 
 
+VkFormat TypeToVkFormat(VALUE_TYPE ValType, Uint32 NumComponents, Bool bIsNormalized)
+{
+    switch (ValType)
+    {
+    case VT_FLOAT16:
+    {
+        VERIFY(!bIsNormalized, "Floating point formats cannot be normalized");
+        switch (NumComponents)
+        {
+        case 1: return VK_FORMAT_R16_SFLOAT;
+        case 2: return VK_FORMAT_R16G16_SFLOAT;
+        case 4: return VK_FORMAT_R16G16B16A16_SFLOAT;
+        default: UNEXPECTED("Unusupported number of components"); return VK_FORMAT_UNDEFINED;
+        }
+    }
+
+    case VT_FLOAT32:
+    {
+        VERIFY(!bIsNormalized, "Floating point formats cannot be normalized");
+        switch (NumComponents)
+        {
+        case 1: return VK_FORMAT_R32_SFLOAT;
+        case 2: return VK_FORMAT_R32G32_SFLOAT;
+        case 3: return VK_FORMAT_R32G32B32_SFLOAT;
+        case 4: return VK_FORMAT_R32G32B32A32_SFLOAT;
+        default: UNEXPECTED("Unusupported number of components"); return VK_FORMAT_UNDEFINED;
+        }
+    }
+
+    case VT_INT32:
+    {
+        VERIFY(!bIsNormalized, "32-bit UNORM formats are not supported. Use R32_FLOAT instead");
+        switch (NumComponents)
+        {
+        case 1: return VK_FORMAT_R32_SINT;
+        case 2: return VK_FORMAT_R32G32_SINT;
+        case 3: return VK_FORMAT_R32G32B32_SINT;
+        case 4: return VK_FORMAT_R32G32B32A32_SINT;
+        default: UNEXPECTED("Unusupported number of components"); return VK_FORMAT_UNDEFINED;
+        }
+    }
+
+    case VT_UINT32:
+    {
+        VERIFY(!bIsNormalized, "32-bit UNORM formats are not supported. Use R32_FLOAT instead");
+        switch (NumComponents)
+        {
+        case 1: return VK_FORMAT_R32_UINT;
+        case 2: return VK_FORMAT_R32G32_UINT;
+        case 3: return VK_FORMAT_R32G32B32_UINT;
+        case 4: return VK_FORMAT_R32G32B32A32_UINT;
+        default: UNEXPECTED("Unusupported number of components"); return VK_FORMAT_UNDEFINED;
+        }
+    }
+
+    case VT_INT16:
+    {
+        if (bIsNormalized)
+        {
+            switch (NumComponents)
+            {
+            case 1: return VK_FORMAT_R16_SNORM;
+            case 2: return VK_FORMAT_R16G16_SNORM;
+            case 4: return VK_FORMAT_R16G16B16A16_SNORM;
+            default: UNEXPECTED("Unusupported number of components"); return VK_FORMAT_UNDEFINED;
+            }
+        }
+        else
+        {
+            switch (NumComponents)
+            {
+            case 1: return VK_FORMAT_R16_SINT;
+            case 2: return VK_FORMAT_R16G16_SINT;
+            case 4: return VK_FORMAT_R16G16B16A16_SINT;
+            default: UNEXPECTED("Unusupported number of components"); return VK_FORMAT_UNDEFINED;
+            }
+        }
+    }
+
+    case VT_UINT16:
+    {
+        if (bIsNormalized)
+        {
+            switch (NumComponents)
+            {
+            case 1: return VK_FORMAT_R16_UNORM;
+            case 2: return VK_FORMAT_R16G16_UNORM;
+            case 4: return VK_FORMAT_R16G16B16A16_UNORM;
+            default: UNEXPECTED("Unusupported number of components"); return VK_FORMAT_UNDEFINED;
+            }
+        }
+        else
+        {
+            switch (NumComponents)
+            {
+            case 1: return VK_FORMAT_R16_UINT;
+            case 2: return VK_FORMAT_R16G16_UINT;
+            case 4: return VK_FORMAT_R16G16B16A16_UINT;
+            default: UNEXPECTED("Unusupported number of components"); return VK_FORMAT_UNDEFINED;
+            }
+        }
+    }
+
+    case VT_INT8:
+    {
+        if (bIsNormalized)
+        {
+            switch (NumComponents)
+            {
+            case 1: return VK_FORMAT_R8_SNORM;
+            case 2: return VK_FORMAT_R8G8_SNORM;
+            case 4: return VK_FORMAT_R8G8B8A8_SNORM;
+            default: UNEXPECTED("Unusupported number of components"); return VK_FORMAT_UNDEFINED;
+            }
+        }
+        else
+        {
+            switch (NumComponents)
+            {
+            case 1: return VK_FORMAT_R8_SINT;
+            case 2: return VK_FORMAT_R8G8_SINT;
+            case 4: return VK_FORMAT_R8G8B8A8_SINT;
+            default: UNEXPECTED("Unusupported number of components"); return VK_FORMAT_UNDEFINED;
+            }
+        }
+    }
+
+    case VT_UINT8:
+    {
+        if (bIsNormalized)
+        {
+            switch (NumComponents)
+            {
+            case 1: return VK_FORMAT_R8_UNORM;
+            case 2: return VK_FORMAT_R8G8_UNORM;
+            case 4: return VK_FORMAT_R8G8B8A8_UNORM;
+            default: UNEXPECTED("Unusupported number of components"); return VK_FORMAT_UNDEFINED;
+            }
+        }
+        else
+        {
+            switch (NumComponents)
+            {
+            case 1: return VK_FORMAT_R8_UINT;
+            case 2: return VK_FORMAT_R8G8_UINT;
+            case 4: return VK_FORMAT_R8G8B8A8_UINT;
+            default: UNEXPECTED("Unusupported number of components"); return VK_FORMAT_UNDEFINED;
+            }
+        }
+    }
+
+    default: UNEXPECTED("Unusupported format"); return VK_FORMAT_UNDEFINED;
+    }
+}
+
 #if 0
 D3D12_COMPARISON_FUNC ComparisonFuncToD3D12ComparisonFunc(COMPARISON_FUNCTION Func)
 {
diff --git a/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanPhysicalDevice.cpp b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanPhysicalDevice.cpp
index 0ccb1a80..f09dd271 100644
--- a/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanPhysicalDevice.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/VulkanUtilities/VulkanPhysicalDevice.cpp
@@ -54,7 +54,7 @@ namespace VulkanUtilities
         }
     }
 
-    uint32_t VulkanPhysicalDevice::FindQueueFamily(VkQueueFlags QueueFlags)
+    uint32_t VulkanPhysicalDevice::FindQueueFamily(VkQueueFlags QueueFlags)const
     {
         // All commands that are allowed on a queue that supports transfer operations are also allowed on 
         // a queue that supports either graphics or compute operations. Thus, if the capabilities of a queue 
@@ -120,7 +120,7 @@ namespace VulkanUtilities
         return FamilyInd;
     }
 
-    bool VulkanPhysicalDevice::IsExtensionSupported(const char *ExtensionName)
+    bool VulkanPhysicalDevice::IsExtensionSupported(const char *ExtensionName)const
     {
         for(const auto& Extension : m_SupportedExtensions)
             if(strcmp(Extension.extensionName, ExtensionName) == 0)
@@ -145,7 +145,7 @@ namespace VulkanUtilities
     //                                 supported for the resource.
     // * requiredProperties   -  required memory properties (device local, host visible, etc.)
     uint32_t VulkanPhysicalDevice::GetMemoryTypeIndex(uint32_t memoryTypeBitsRequirement,
-                                                      VkMemoryPropertyFlags requiredProperties)
+                                                      VkMemoryPropertyFlags requiredProperties)const
     {
         // Iterate over all memory types available for the device
         // For each pair of elements X and Y returned in memoryTypes, X must be placed at a lower index position than Y if: