Implemented vulkan sampler creation

6 files changed, 123 insertions, 277 deletions

diff --git a/Graphics/GraphicsEngineVulkan/include/SamplerVkImpl.h b/Graphics/GraphicsEngineVulkan/include/SamplerVkImpl.h
index 9ed871e2..1756b097 100644
--- a/Graphics/GraphicsEngineVulkan/include/SamplerVkImpl.h
+++ b/Graphics/GraphicsEngineVulkan/include/SamplerVkImpl.h
@@ -29,8 +29,7 @@
 #include "SamplerVk.h"
 #include "RenderDeviceVk.h"
 #include "SamplerBase.h"
-#include "DescriptorHeap.h"
-
+#include "VulkanUtilities/VulkanObjectWrappers.h"
 namespace Diligent
 {
 
@@ -46,12 +45,12 @@ public:
 
     virtual void QueryInterface( const Diligent::INTERFACE_ID &IID, IObject **ppInterface )override;
 
-    //virtual Vk_CPU_DESCRIPTOR_HANDLE GetCPUDescriptorHandle()override{ return m_Descriptor.GetCpuHandle(); }
+    virtual VkSampler GetVkSampler()override final{return m_VkSampler;}
 
 private:
     friend class ShaderVkImpl;
-    /// Vk sampler
-    DescriptorHeapAllocation m_Descriptor;
+    /// Vk sampler handle
+    VulkanUtilities::SamplerWrapper m_VkSampler;
 };
 
 }
diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.h b/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.h
index f5b2859c..cc2f794a 100644
--- a/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.h
+++ b/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.h
@@ -52,24 +52,10 @@ void PrimitiveTopology_To_VkPrimitiveTopologyAndPatchCPCount(PRIMITIVE_TOPOLOGY
                                                              VkPrimitiveTopology &VkPrimTopology, 
                                                              uint32_t &PatchControlPoints);
 
-#if 0
-D3D12_COMPARISON_FUNC ComparisonFuncToD3D12ComparisonFunc(COMPARISON_FUNCTION Func);
-D3D12_FILTER FilterTypeToD3D12Filter(FILTER_TYPE MinFilter, FILTER_TYPE MagFilter, FILTER_TYPE MipFilter);
-D3D12_TEXTURE_ADDRESS_MODE TexAddressModeToD3D12AddressMode(TEXTURE_ADDRESS_MODE Mode);
-D3D12_PRIMITIVE_TOPOLOGY TopologyToD3D12Topology(PRIMITIVE_TOPOLOGY Topology);
+VkCompareOp ComparisonFuncToVkCompareOp(COMPARISON_FUNCTION CmpFunc);
+VkFilter FilterTypeToVkFilter(FILTER_TYPE FilterType);
+VkSamplerMipmapMode FilterTypeToVkMipmapMode(FILTER_TYPE FilterType);
+VkSamplerAddressMode AddressModeToVkAddressMode(TEXTURE_ADDRESS_MODE AddressMode);
+VkBorderColor BorderColorToVkBorderColor(const Float32 BorderColor[]);
 
-
-void LayoutElements_To_D3D12_INPUT_ELEMENT_DESCs(const std::vector<LayoutElement, STDAllocatorRawMem<LayoutElement>> &LayoutElements, 
-                                                 std::vector<D3D12_INPUT_ELEMENT_DESC, STDAllocatorRawMem<D3D12_INPUT_ELEMENT_DESC> > &d3d12InputElements);
-
-void TextureViewDesc_to_D3D12_SRV_DESC(const TextureViewDesc& SRVDesc, D3D12_SHADER_RESOURCE_VIEW_DESC  &D3D12SRVDesc, Uint32 SampleCount);
-void TextureViewDesc_to_D3D12_RTV_DESC(const TextureViewDesc& RTVDesc, D3D12_RENDER_TARGET_VIEW_DESC    &D3D12RTVDesc, Uint32 SampleCount);
-void TextureViewDesc_to_D3D12_DSV_DESC(const TextureViewDesc& DSVDesc, D3D12_DEPTH_STENCIL_VIEW_DESC    &D3D12DSVDesc, Uint32 SampleCount);
-void TextureViewDesc_to_D3D12_UAV_DESC(const TextureViewDesc& UAVDesc, D3D12_UNORDERED_ACCESS_VIEW_DESC &D3D12UAVDesc);
-
-void BufferViewDesc_to_D3D12_SRV_DESC(const BufferDesc &BuffDesc, const BufferViewDesc& SRVDesc, D3D12_SHADER_RESOURCE_VIEW_DESC &D3D12SRVDesc);
-void BufferViewDesc_to_D3D12_UAV_DESC(const BufferDesc &BuffDesc, const BufferViewDesc& UAVDesc, D3D12_UNORDERED_ACCESS_VIEW_DESC &D3D12UAVDesc);
-
-D3D12_STATIC_BORDER_COLOR BorderColorToD3D12StaticBorderColor(const Float32 BorderColor[]);
-#endif
 }
diff --git a/Graphics/GraphicsEngineVulkan/interface/SamplerVk.h b/Graphics/GraphicsEngineVulkan/interface/SamplerVk.h
index 5f122327..a849033d 100644
--- a/Graphics/GraphicsEngineVulkan/interface/SamplerVk.h
+++ b/Graphics/GraphicsEngineVulkan/interface/SamplerVk.h
@@ -40,11 +40,8 @@ class ISamplerVk : public ISampler
 {
 public:
 
-    /// Returns a CPU descriptor handle of the D3D12 sampler object
-    
-    /// The method does *NOT* call AddRef() on the returned interface,
-    /// so Release() must not be called.
-    //virtual D3D12_CPU_DESCRIPTOR_HANDLE GetCPUDescriptorHandle() = 0;
+    /// Returns a vulkan sampler object handle
+    virtual VkSampler GetVkSampler() = 0;
 };
 
 }
diff --git a/Graphics/GraphicsEngineVulkan/src/RenderDeviceFactoryVk.cpp b/Graphics/GraphicsEngineVulkan/src/RenderDeviceFactoryVk.cpp
index 223dbafe..7d0c2cea 100644
--- a/Graphics/GraphicsEngineVulkan/src/RenderDeviceFactoryVk.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/RenderDeviceFactoryVk.cpp
@@ -149,8 +149,14 @@ void EngineFactoryVkImpl::CreateDeviceAndContextsVk( const EngineVkAttribs& Crea
         DeviceCreateInfo.ppEnabledLayerNames = nullptr; // Deprecated and ignored
         DeviceCreateInfo.queueCreateInfoCount = 1;
         DeviceCreateInfo.pQueueCreateInfos = &QueueInfo;
-        DeviceCreateInfo.pEnabledFeatures = nullptr; // NULL or a pointer to a VkPhysicalDeviceFeatures structure that contains 
-                                                     // boolean indicators of all the features to be enabled.
+        VkPhysicalDeviceFeatures DeviceFeatures = {};
+        DeviceFeatures.depthBiasClamp    = VK_TRUE;
+        DeviceFeatures.fillModeNonSolid  = VK_TRUE;
+        DeviceFeatures.depthClamp        = VK_TRUE;
+        DeviceFeatures.independentBlend  = VK_TRUE;
+        DeviceFeatures.samplerAnisotropy = VK_TRUE;
+        DeviceCreateInfo.pEnabledFeatures = &DeviceFeatures; // NULL or a pointer to a VkPhysicalDeviceFeatures structure that contains 
+                                                             // boolean indicators of all the features to be enabled.
 
         std::vector<const char*> DeviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
         const bool DebugMarkersSupported = PhysicalDevice->IsExtensionSupported(VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
diff --git a/Graphics/GraphicsEngineVulkan/src/SamplerVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/SamplerVkImpl.cpp
index 4d84dfa3..0b6f4057 100644
--- a/Graphics/GraphicsEngineVulkan/src/SamplerVkImpl.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/SamplerVkImpl.cpp
@@ -25,38 +25,50 @@
 #include "SamplerVkImpl.h"
 #include "RenderDeviceVkImpl.h"
 #include "VulkanTypeConversions.h"
+#include "GraphicsAccessories.h"
 
 namespace Diligent
 {
 
-SamplerVkImpl::SamplerVkImpl(IReferenceCounters *pRefCounters, class RenderDeviceVkImpl *pRenderDeviceVk, const SamplerDesc& SamplerDesc) : 
+SamplerVkImpl::SamplerVkImpl(IReferenceCounters *pRefCounters, RenderDeviceVkImpl *pRenderDeviceVk, const SamplerDesc& SamplerDesc) : 
     TSamplerBase(pRefCounters, pRenderDeviceVk, SamplerDesc)
 {
-#if 0
-    auto *pVkDevice = pRenderDeviceVk->GetVkDevice();
-    Vk_SAMPLER_DESC VkSamplerDesc = 
-    {
-        FilterTypeToVkFilter(SamplerDesc.MinFilter, SamplerDesc.MagFilter, SamplerDesc.MipFilter),
-        TexAddressModeToVkAddressMode(SamplerDesc.AddressU),
-        TexAddressModeToVkAddressMode(SamplerDesc.AddressV),
-        TexAddressModeToVkAddressMode(SamplerDesc.AddressW),
-        SamplerDesc.MipLODBias,
-        SamplerDesc.MaxAnisotropy,
-        ComparisonFuncToVkComparisonFunc(SamplerDesc.ComparisonFunc),
-        {SamplerDesc.BorderColor[0], SamplerDesc.BorderColor[1], SamplerDesc.BorderColor[2], SamplerDesc.BorderColor[3]},
-        SamplerDesc.MinLOD,
-        SamplerDesc.MaxLOD
-    };
+    const auto &LogicalDevice = pRenderDeviceVk->GetLogicalDevice();
+    VkSamplerCreateInfo SamplerCI = {};
+    SamplerCI.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+    SamplerCI.pNext = nullptr;
+    SamplerCI.flags = 0; // reserved for future use
+    SamplerCI.magFilter = FilterTypeToVkFilter(m_Desc.MagFilter);
+    SamplerCI.minFilter = FilterTypeToVkFilter(m_Desc.MinFilter);
+    SamplerCI.mipmapMode = FilterTypeToVkMipmapMode(m_Desc.MipFilter);
+    SamplerCI.addressModeU = AddressModeToVkAddressMode(m_Desc.AddressU);
+    SamplerCI.addressModeV = AddressModeToVkAddressMode(m_Desc.AddressV);
+    SamplerCI.addressModeW = AddressModeToVkAddressMode(m_Desc.AddressW);
+    SamplerCI.mipLodBias = m_Desc.MipLODBias;
+    SamplerCI.anisotropyEnable = IsAnisotropicFilter(m_Desc.MinFilter);
+    VERIFY(SamplerCI.anisotropyEnable && IsAnisotropicFilter(m_Desc.MagFilter) ||
+           !SamplerCI.anisotropyEnable && !IsAnisotropicFilter(m_Desc.MagFilter),
+           "Min and mag fiters must both be either anisotropic filters or non-anisotropic ones");
 
-    auto CPUDescriptorAlloc = pRenderDeviceVk->AllocateDescriptor(Vk_DESCRIPTOR_HEAP_TYPE_SAMPLER);
-    m_Descriptor = std::move(CPUDescriptorAlloc);
-	pVkDevice->CreateSampler(&VkSamplerDesc, m_Descriptor.GetCpuHandle());
-#endif
+    SamplerCI.maxAnisotropy = static_cast<float>(m_Desc.MaxAnisotropy);
+    SamplerCI.compareEnable = IsComparisonFilter(m_Desc.MinFilter);
+    VERIFY( SamplerCI.compareEnable && IsComparisonFilter(m_Desc.MagFilter) || 
+            !SamplerCI.compareEnable && !IsComparisonFilter(m_Desc.MagFilter), 
+            "Min and mag fiters must both be either comparison filters or non-comparison ones");
+
+    SamplerCI.compareOp = ComparisonFuncToVkCompareOp(m_Desc.ComparisonFunc);
+    SamplerCI.minLod = m_Desc.MinLOD;
+    SamplerCI.maxLod = m_Desc.MaxLOD;
+    SamplerCI.borderColor = BorderColorToVkBorderColor(m_Desc.BorderColor);
+    SamplerCI.unnormalizedCoordinates = VK_FALSE;
+
+    m_VkSampler = LogicalDevice.CreateSampler(SamplerCI);
 }
 
 SamplerVkImpl::~SamplerVkImpl()
 {
-
+    auto pDeviceVkImpl = ValidatedCast<RenderDeviceVkImpl>(GetDevice());
+    pDeviceVkImpl->SafeReleaseVkObject(std::move(m_VkSampler));
 }
 
 IMPLEMENT_QUERY_INTERFACE( SamplerVkImpl, IID_SamplerVk, TSamplerBase )
diff --git a/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp b/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
index a9a7392d..971d9c39 100644
--- a/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
@@ -950,7 +950,7 @@ void InputLayoutDesc_To_VkVertexInputStateCI(const InputLayoutDesc& LayoutDesc,
             BindingDescInd = VertexInputStateCI.vertexBindingDescriptionCount++;
             auto &BindingDesc = BindingDescriptions[BindingDescInd];
             BindingDesc.binding = LayoutElem.BufferSlot;
-            //BindingDesc.stride = LayoutElem.
+            BindingDesc.stride = 4*3;//LayoutElem.
             BindingDesc.inputRate = LayoutElemFrequencyToVkInputRate(LayoutElem.Frequency);
         }
 
@@ -1001,255 +1001,101 @@ void PrimitiveTopology_To_VkPrimitiveTopologyAndPatchCPCount(PRIMITIVE_TOPOLOGY
     PatchControlPoints = static_cast<uint32_t>(VkPrimTopology) - static_cast<uint32_t>(PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST) + 1;
 }
 
-#if 0
-D3D12_COMPARISON_FUNC ComparisonFuncToD3D12ComparisonFunc(COMPARISON_FUNCTION Func)
+VkFilter FilterTypeToVkFilter(FILTER_TYPE FilterType)
 {
-    return ComparisonFuncToD3DComparisonFunc<D3D12_COMPARISON_FUNC>(Func);
-}
-
-D3D12_FILTER FilterTypeToD3D12Filter(FILTER_TYPE MinFilter, FILTER_TYPE MagFilter, FILTER_TYPE MipFilter)
-{
-    return FilterTypeToD3DFilter<D3D12_FILTER>(MinFilter, MagFilter, MipFilter);
-}
-
-D3D12_TEXTURE_ADDRESS_MODE TexAddressModeToD3D12AddressMode(TEXTURE_ADDRESS_MODE Mode)
-{
-    return TexAddressModeToD3DAddressMode<D3D12_TEXTURE_ADDRESS_MODE>(Mode);
-}
-
-void DepthStencilStateDesc_To_D3D12_DEPTH_STENCIL_DESC(const DepthStencilStateDesc &DepthStencilDesc, D3D12_DEPTH_STENCIL_DESC &d3d12DSSDesc)
-{
-    DepthStencilStateDesc_To_D3D_DEPTH_STENCIL_DESC<D3D12_DEPTH_STENCIL_DESC, D3D12_DEPTH_STENCILOP_DESC, D3D12_STENCIL_OP, D3D12_COMPARISON_FUNC>(DepthStencilDesc, d3d12DSSDesc);
-}
-
-void RasterizerStateDesc_To_D3D12_RASTERIZER_DESC(const RasterizerStateDesc &RasterizerDesc, D3D12_RASTERIZER_DESC &d3d12RSDesc)
-{
-    RasterizerStateDesc_To_D3D_RASTERIZER_DESC<D3D12_RASTERIZER_DESC, D3D12_FILL_MODE, D3D12_CULL_MODE>(RasterizerDesc, d3d12RSDesc);
-
-    // The sample count that is forced while UAV rendering or rasterizing. 
-    // Valid values are 0, 1, 2, 4, 8, and optionally 16. 0 indicates that 
-    // the sample count is not forced.
-    d3d12RSDesc.ForcedSampleCount     = 0;
-
-    d3d12RSDesc.ConservativeRaster    = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
-}
-
-
-
-D3D12_LOGIC_OP LogicOperationToD3D12LogicOp( LOGIC_OPERATION lo )
-{
-    // Note that this code is safe for multithreaded environments since
-    // bIsInit is set to true only AFTER the entire map is initialized.
-    static bool bIsInit = false;
-    static D3D12_LOGIC_OP D3D12LogicOp[LOGIC_OP_NUM_OPERATIONS] = {};
-    if( !bIsInit )
-    {
-        // In a multithreaded environment, several threads can potentially enter
-        // this block. This is not a problem since they will just initialize the 
-        // memory with the same values more than once
-        
-        bIsInit = true;
-    }
-    if( lo >= LOGIC_OP_CLEAR && lo < LOGIC_OP_NUM_OPERATIONS )
-    {
-        auto d3dlo = D3D12LogicOp[lo];
-        return d3dlo;
-    }
-    else
-    {
-        UNEXPECTED("Incorrect blend factor (", lo, ")" );
-        return static_cast<D3D12_LOGIC_OP>( 0 );
-    }
-}
-
-
-void BlendStateDesc_To_D3D12_BLEND_DESC(const BlendStateDesc &BSDesc, D3D12_BLEND_DESC &d3d12BlendDesc)
-{
-    BlendStateDescToD3DBlendDesc<D3D12_BLEND_DESC, D3D12_BLEND, D3D12_BLEND_OP>(BSDesc, d3d12BlendDesc);
-
-    for( int i = 0; i < 8; ++i )
-    {
-        const auto& SrcRTDesc = BSDesc.RenderTargets[i];
-        auto &DstRTDesc = d3d12BlendDesc.RenderTarget[i];
-
-        // The following members only present in D3D_RENDER_TARGET_BLEND_DESC
-        DstRTDesc.LogicOpEnable = SrcRTDesc.LogicOperationEnable ? TRUE : FALSE;
-        DstRTDesc.LogicOp = LogicOperationToD3D12LogicOp(SrcRTDesc.LogicOp);
-    }
-}
-
-void LayoutElements_To_D3D12_INPUT_ELEMENT_DESCs(const std::vector<LayoutElement, STDAllocatorRawMem<LayoutElement>> &LayoutElements, 
-                                                 std::vector<D3D12_INPUT_ELEMENT_DESC, STDAllocatorRawMem<D3D12_INPUT_ELEMENT_DESC> > &d3d12InputElements)
-{
-    LayoutElements_To_D3D_INPUT_ELEMENT_DESCs<D3D12_INPUT_ELEMENT_DESC>(LayoutElements, d3d12InputElements);
-}
-
-D3D12_PRIMITIVE_TOPOLOGY TopologyToD3D12Topology(PRIMITIVE_TOPOLOGY Topology)
-{
-    return TopologyToD3DTopology<D3D12_PRIMITIVE_TOPOLOGY>(Topology);
-}
-
-
-
-void TextureViewDesc_to_D3D12_SRV_DESC(const TextureViewDesc& SRVDesc, D3D12_SHADER_RESOURCE_VIEW_DESC &D3D12SRVDesc, Uint32 SampleCount)
-{
-    TextureViewDesc_to_D3D_SRV_DESC(SRVDesc, D3D12SRVDesc, SampleCount);
-    D3D12SRVDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
-    switch (SRVDesc.TextureDim)
+    switch(FilterType)
     {
-        case RESOURCE_DIM_TEX_1D:
-            D3D12SRVDesc.Texture1D.ResourceMinLODClamp = 0;
-        break;
-
-        case RESOURCE_DIM_TEX_1D_ARRAY:
-            D3D12SRVDesc.Texture1DArray.ResourceMinLODClamp = 0;
-        break;
-
-        case RESOURCE_DIM_TEX_2D:
-            if( SampleCount > 1 )
-            {
-            }
-            else
-            {
-                D3D12SRVDesc.Texture2D.PlaneSlice = 0;
-                D3D12SRVDesc.Texture2D.ResourceMinLODClamp = 0;
-            }
-        break;
-
-        case RESOURCE_DIM_TEX_2D_ARRAY:
-            if( SampleCount > 1 )
-            {
-            }
-            else
-            {
-                D3D12SRVDesc.Texture2DArray.PlaneSlice = 0;
-                D3D12SRVDesc.Texture2DArray.ResourceMinLODClamp = 0;
-            }
-        break;
-
-        case RESOURCE_DIM_TEX_3D:
-            D3D12SRVDesc.Texture3D.ResourceMinLODClamp = 0;
-        break;
-
-        case RESOURCE_DIM_TEX_CUBE:
-            D3D12SRVDesc.TextureCube.ResourceMinLODClamp = 0;
-        break;
-
-        case RESOURCE_DIM_TEX_CUBE_ARRAY:
-            D3D12SRVDesc.TextureCubeArray.ResourceMinLODClamp = 0;
-        break;
+        case FILTER_TYPE_UNKNOWN: 
+            UNEXPECTED("Unknown filter type");
+            return VK_FILTER_NEAREST;
+
+        case FILTER_TYPE_POINT:
+        case FILTER_TYPE_COMPARISON_POINT:
+        case FILTER_TYPE_MINIMUM_POINT:
+        case FILTER_TYPE_MAXIMUM_POINT:
+            return VK_FILTER_NEAREST;
+
+        case FILTER_TYPE_LINEAR:
+        case FILTER_TYPE_ANISOTROPIC:
+        case FILTER_TYPE_COMPARISON_LINEAR:
+        case FILTER_TYPE_COMPARISON_ANISOTROPIC:
+        case FILTER_TYPE_MINIMUM_LINEAR:
+        case FILTER_TYPE_MINIMUM_ANISOTROPIC:
+        case FILTER_TYPE_MAXIMUM_LINEAR:     
+        case FILTER_TYPE_MAXIMUM_ANISOTROPIC:
+            return VK_FILTER_LINEAR;
 
         default:
-            UNEXPECTED( "Unexpected view type" );
+            UNEXPECTED("Unexpected filter type");
+            return VK_FILTER_NEAREST;
     }
 }
 
-void TextureViewDesc_to_D3D12_RTV_DESC(const TextureViewDesc& RTVDesc, D3D12_RENDER_TARGET_VIEW_DESC &D3D12RTVDesc, Uint32 SampleCount)
+VkSamplerMipmapMode FilterTypeToVkMipmapMode(FILTER_TYPE FilterType)
 {
-    TextureViewDesc_to_D3D_RTV_DESC(RTVDesc, D3D12RTVDesc, SampleCount);
-    switch (RTVDesc.TextureDim)
+    switch (FilterType)
     {
-        case RESOURCE_DIM_TEX_1D:
-        break;
-
-        case RESOURCE_DIM_TEX_1D_ARRAY:
-        break;
-
-        case RESOURCE_DIM_TEX_2D:
-            if( SampleCount > 1 )
-            {
-            }
-            else
-            {
-                D3D12RTVDesc.Texture2D.PlaneSlice = 0;
-            }
-        break;
-
-        case RESOURCE_DIM_TEX_2D_ARRAY:
-            if( SampleCount > 1 )
-            {
-            }
-            else
-            {
-                D3D12RTVDesc.Texture2DArray.PlaneSlice = 0;
-            }
-        break;
-
-        case RESOURCE_DIM_TEX_3D:
-        break;
+        case FILTER_TYPE_UNKNOWN:
+            UNEXPECTED("Unknown filter type");
+            return VK_SAMPLER_MIPMAP_MODE_NEAREST;
+
+        case FILTER_TYPE_POINT:
+        case FILTER_TYPE_COMPARISON_POINT:
+        case FILTER_TYPE_MINIMUM_POINT:
+        case FILTER_TYPE_MAXIMUM_POINT:
+            return VK_SAMPLER_MIPMAP_MODE_NEAREST;
+
+        case FILTER_TYPE_LINEAR:
+        case FILTER_TYPE_ANISOTROPIC:
+        case FILTER_TYPE_COMPARISON_LINEAR:
+        case FILTER_TYPE_COMPARISON_ANISOTROPIC:
+        case FILTER_TYPE_MINIMUM_LINEAR:
+        case FILTER_TYPE_MINIMUM_ANISOTROPIC:
+        case FILTER_TYPE_MAXIMUM_LINEAR:
+        case FILTER_TYPE_MAXIMUM_ANISOTROPIC:
+            return VK_SAMPLER_MIPMAP_MODE_LINEAR;
 
         default:
-            UNEXPECTED( "Unexpected view type" );
+            UNEXPECTED("Only point and linear filter types are allowed for mipmap mode");
+            return VK_SAMPLER_MIPMAP_MODE_NEAREST;
     }
 }
 
-void TextureViewDesc_to_D3D12_DSV_DESC(const TextureViewDesc& DSVDesc, D3D12_DEPTH_STENCIL_VIEW_DESC &D3D12DSVDesc, Uint32 SampleCount)
+VkSamplerAddressMode AddressModeToVkAddressMode(TEXTURE_ADDRESS_MODE AddressMode)
 {
-    TextureViewDesc_to_D3D_DSV_DESC(DSVDesc, D3D12DSVDesc, SampleCount);
-    D3D12DSVDesc.Flags = D3D12_DSV_FLAG_NONE;
-}
-
-void TextureViewDesc_to_D3D12_UAV_DESC(const TextureViewDesc& UAVDesc, D3D12_UNORDERED_ACCESS_VIEW_DESC &D3D12UAVDesc)
-{
-    TextureViewDesc_to_D3D_UAV_DESC(UAVDesc, D3D12UAVDesc);
-    switch (UAVDesc.TextureDim)
+    switch(AddressMode)
     {
-        case RESOURCE_DIM_TEX_1D:
-        break;
-
-        case RESOURCE_DIM_TEX_1D_ARRAY:
-        break;
+        case TEXTURE_ADDRESS_UNKNOWN:
+            UNEXPECTED("Unknown address mode");
+            return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
 
-        case RESOURCE_DIM_TEX_2D:
-            D3D12UAVDesc.Texture2D.PlaneSlice = 0;
-        break;
-
-        case RESOURCE_DIM_TEX_2D_ARRAY:
-            D3D12UAVDesc.Texture2DArray.PlaneSlice = 0;
-        break;
-
-        case RESOURCE_DIM_TEX_3D:
-        break;
+        case TEXTURE_ADDRESS_WRAP:   return VK_SAMPLER_ADDRESS_MODE_REPEAT;
+        case TEXTURE_ADDRESS_MIRROR: return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
+        case TEXTURE_ADDRESS_CLAMP:  return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+        case TEXTURE_ADDRESS_BORDER: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
+        case TEXTURE_ADDRESS_MIRROR_ONCE: return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
 
         default:
-            UNEXPECTED( "Unexpected view type" );
+            UNEXPECTED("Unexpected address mode");
+            return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
     }
 }
 
-
-void BufferViewDesc_to_D3D12_SRV_DESC(const BufferDesc &BuffDesc, const BufferViewDesc& SRVDesc, D3D12_SHADER_RESOURCE_VIEW_DESC &D3D12SRVDesc)
-{
-    BufferViewDesc_to_D3D_SRV_DESC(BuffDesc, SRVDesc, D3D12SRVDesc);
-    D3D12SRVDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
-    D3D12SRVDesc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
-    VERIFY_EXPR(BuffDesc.BindFlags & BIND_SHADER_RESOURCE);
-    if (BuffDesc.Mode == BUFFER_MODE_STRUCTURED)
-        D3D12SRVDesc.Buffer.StructureByteStride = BuffDesc.ElementByteStride; 
-}
-
-void BufferViewDesc_to_D3D12_UAV_DESC(const BufferDesc &BuffDesc, const BufferViewDesc& UAVDesc, D3D12_UNORDERED_ACCESS_VIEW_DESC &D3D12UAVDesc)
+VkBorderColor BorderColorToVkBorderColor(const Float32 BorderColor[])
 {
-    BufferViewDesc_to_D3D_UAV_DESC(BuffDesc, UAVDesc, D3D12UAVDesc);
-    D3D12UAVDesc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE;
-    VERIFY_EXPR(BuffDesc.BindFlags & BIND_UNORDERED_ACCESS);
-    if (BuffDesc.Mode == BUFFER_MODE_STRUCTURED)
-        D3D12UAVDesc.Buffer.StructureByteStride = BuffDesc.ElementByteStride; 
-}
-
-D3D12_STATIC_BORDER_COLOR BorderColorToD3D12StaticBorderColor(const Float32 BorderColor[])
-{
-    D3D12_STATIC_BORDER_COLOR StaticBorderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK;
-    if(BorderColor[0] == 0 && BorderColor[1] == 0 && BorderColor[2] == 0 && BorderColor[3] == 0)
-        StaticBorderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK;
-    else if(BorderColor[0] == 0 && BorderColor[1] == 0 && BorderColor[2] == 0 && BorderColor[3] == 1)
-        StaticBorderColor = D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK;
-    else if(BorderColor[0] == 1 && BorderColor[1] == 1 && BorderColor[2] == 1 && BorderColor[3] == 0)
-        StaticBorderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE;
+    VkBorderColor vkBorderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
+    if (BorderColor[0] == 0 && BorderColor[1] == 0 && BorderColor[2] == 0 && BorderColor[3] == 0)
+        vkBorderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
+    else if (BorderColor[0] == 0 && BorderColor[1] == 0 && BorderColor[2] == 0 && BorderColor[3] == 1)
+        vkBorderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
+    else if (BorderColor[0] == 1 && BorderColor[1] == 1 && BorderColor[2] == 1 && BorderColor[3] == 1)
+        vkBorderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
     else
     {
-        LOG_ERROR_MESSAGE("Static samplers only allow transparent black (0,0,0,1), opaque black (0,0,0,0) or opaque white (1,1,1,0) as border colors.");
+        LOG_ERROR_MESSAGE("Vulkan samplers only allow transparent black (0,0,0,0), opaque black (0,0,0,1) or opaque white (1,1,1,1) as border colors.");
     }
-    return StaticBorderColor;
+
+    return vkBorderColor;
 }
-#endif
+
 }