Implemented input vertex layout conversion in Vulkan

5 files changed, 179 insertions, 300 deletions

diff --git a/Graphics/GraphicsEngineVulkan/CMakeLists.txt b/Graphics/GraphicsEngineVulkan/CMakeLists.txt
index 2ceabf85..bf8a78ea 100644
--- a/Graphics/GraphicsEngineVulkan/CMakeLists.txt
+++ b/Graphics/GraphicsEngineVulkan/CMakeLists.txt
@@ -10,7 +10,6 @@ set(INCLUDE
     include/CommandQueueVkImpl.h
     include/VulkanResourceBase.h
     include/VulkanTypeConversions.h
-    include/VulkanTypeDefinitions.h
     include/VulkanUtils.h
     include/DescriptorHeap.h
     include/DeviceContextVkImpl.h
diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.h b/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.h
index bdb0c792..b8da039e 100644
--- a/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.h
+++ b/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.h
@@ -26,6 +26,7 @@
 /// \file
 /// Type conversion routines
 
+#include <array>
 #include "GraphicsTypes.h"
 
 namespace Diligent
@@ -42,6 +43,10 @@ void BlendStateDesc_To_VkBlendStateCI(const BlendStateDesc &BSDesc,
                                       VkPipelineColorBlendStateCreateInfo &ColorBlendStateCI,
                                       std::vector<VkPipelineColorBlendAttachmentState> &ColorBlendAttachments);
 
+void InputLayoutDesc_To_VkVertexInputStateCI(const InputLayoutDesc& LayoutDesc, 
+                                             VkPipelineVertexInputStateCreateInfo &VertexInputStateCI,
+                                             std::array<VkVertexInputBindingDescription, iMaxLayoutElements>& BindingDescriptions,
+                                             std::array<VkVertexInputAttributeDescription, iMaxLayoutElements>& AttributeDescription);
 
 #if 0
 D3D12_COMPARISON_FUNC ComparisonFuncToD3D12ComparisonFunc(COMPARISON_FUNCTION Func);
diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanTypeDefinitions.h b/Graphics/GraphicsEngineVulkan/include/VulkanTypeDefinitions.h
deleted file mode 100644
index f0ea539d..00000000
--- a/Graphics/GraphicsEngineVulkan/include/VulkanTypeDefinitions.h
+++ /dev/null
@@ -1,189 +0,0 @@
-/*     Copyright 2015-2018 Egor Yusov
- *  
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- * 
- *     http://www.apache.org/licenses/LICENSE-2.0
- * 
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS.
- *
- *  In no event and under no legal theory, whether in tort (including negligence), 
- *  contract, or otherwise, unless required by applicable law (such as deliberate 
- *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
- *  liable for any damages, including any direct, indirect, special, incidental, 
- *  or consequential damages of any character arising as a result of this License or 
- *  out of the use or inability to use the software (including but not limited to damages 
- *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and 
- *  all other commercial damages or losses), even if such Contributor has been advised 
- *  of the possibility of such damages.
- */
-
-#pragma once
-
-/// \file
-/// Definitions of D3D12 types
-
-#if 0
-// Filters
-#define D3D_FILTER_MIN_MAG_MIP_POINT                D3D12_FILTER_MIN_MAG_MIP_POINT
-#define D3D_FILTER_MIN_MAG_POINT_MIP_LINEAR         D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR
-#define D3D_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT   D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT
-#define D3D_FILTER_MIN_POINT_MAG_MIP_LINEAR         D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR
-#define D3D_FILTER_MIN_LINEAR_MAG_MIP_POINT         D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT
-#define D3D_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR  D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR
-#define D3D_FILTER_MIN_MAG_LINEAR_MIP_POINT         D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT
-#define D3D_FILTER_MIN_MAG_MIP_LINEAR               D3D12_FILTER_MIN_MAG_MIP_LINEAR
-#define D3D_FILTER_ANISOTROPIC                      D3D12_FILTER_ANISOTROPIC
-
-#define D3D_FILTER_COMPARISON_MIN_MAG_MIP_POINT                 D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT
-#define D3D_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR          D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR
-#define D3D_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT    D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT
-#define D3D_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR          D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR
-#define D3D_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT          D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT
-#define D3D_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR   D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR
-#define D3D_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT          D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT
-#define D3D_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR                D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR
-#define D3D_FILTER_COMPARISON_ANISOTROPIC                       D3D12_FILTER_COMPARISON_ANISOTROPIC
-
-#define D3D_FILTER_MINIMUM_MIN_MAG_MIP_POINT                D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT
-#define D3D_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR         D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR
-#define D3D_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT   D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT
-#define D3D_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR         D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR
-#define D3D_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT         D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT
-#define D3D_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR  D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR
-#define D3D_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT         D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT
-#define D3D_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR               D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR
-#define D3D_FILTER_MINIMUM_ANISOTROPIC                      D3D12_FILTER_MINIMUM_ANISOTROPIC
-
-#define D3D_FILTER_MAXIMUM_MIN_MAG_MIP_POINT                D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT
-#define D3D_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR         D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR
-#define D3D_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT   D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT
-#define D3D_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR         D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR
-#define D3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT         D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT
-#define D3D_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR  D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR
-#define D3D_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT         D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT
-#define D3D_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR               D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR
-#define D3D_FILTER_MAXIMUM_ANISOTROPIC                      D3D12_FILTER_MAXIMUM_ANISOTROPIC
-
-// Comparison functions
-#define D3D_COMPARISON_FUNC_NEVER           D3D12_COMPARISON_FUNC_NEVER
-#define D3D_COMPARISON_FUNC_LESS            D3D12_COMPARISON_FUNC_LESS
-#define D3D_COMPARISON_FUNC_EQUAL           D3D12_COMPARISON_FUNC_EQUAL
-#define D3D_COMPARISON_FUNC_LESS_EQUAL      D3D12_COMPARISON_FUNC_LESS_EQUAL
-#define D3D_COMPARISON_FUNC_GREATER         D3D12_COMPARISON_FUNC_GREATER
-#define D3D_COMPARISON_FUNC_NOT_EQUAL       D3D12_COMPARISON_FUNC_NOT_EQUAL
-#define D3D_COMPARISON_FUNC_GREATER_EQUAL   D3D12_COMPARISON_FUNC_GREATER_EQUAL
-#define D3D_COMPARISON_FUNC_ALWAYS          D3D12_COMPARISON_FUNC_ALWAYS
-
-// Stencil operations
-#define D3D_STENCIL_OP_KEEP     D3D12_STENCIL_OP_KEEP
-#define D3D_STENCIL_OP_ZERO     D3D12_STENCIL_OP_ZERO
-#define D3D_STENCIL_OP_REPLACE  D3D12_STENCIL_OP_REPLACE
-#define D3D_STENCIL_OP_INCR_SAT D3D12_STENCIL_OP_INCR_SAT
-#define D3D_STENCIL_OP_DECR_SAT D3D12_STENCIL_OP_DECR_SAT
-#define D3D_STENCIL_OP_INVERT   D3D12_STENCIL_OP_INVERT
-#define D3D_STENCIL_OP_INCR     D3D12_STENCIL_OP_INCR
-#define D3D_STENCIL_OP_DECR     D3D12_STENCIL_OP_DECR
-
-// Depth write masks
-#define D3D_DEPTH_WRITE_MASK_ALL    D3D12_DEPTH_WRITE_MASK_ALL
-#define D3D_DEPTH_WRITE_MASK_ZERO   D3D12_DEPTH_WRITE_MASK_ZERO
-
-// Cull modes
-#define D3D_CULL_MODE_NONE  D3D12_CULL_MODE_NONE
-#define D3D_CULL_MODE_FRONT D3D12_CULL_MODE_FRONT
-#define D3D_CULL_MODE_BACK  D3D12_CULL_MODE_BACK
-
-// Fill modes
-#define D3D_FILL_MODE_WIREFRAME D3D12_FILL_MODE_WIREFRAME
-#define D3D_FILL_MODE_SOLID     D3D12_FILL_MODE_SOLID
-
-// Blend sources
-#define D3D_BLEND_ZERO              D3D12_BLEND_ZERO
-#define D3D_BLEND_ONE               D3D12_BLEND_ONE
-#define D3D_BLEND_SRC_COLOR         D3D12_BLEND_SRC_COLOR
-#define D3D_BLEND_INV_SRC_COLOR     D3D12_BLEND_INV_SRC_COLOR
-#define D3D_BLEND_SRC_ALPHA         D3D12_BLEND_SRC_ALPHA
-#define D3D_BLEND_INV_SRC_ALPHA     D3D12_BLEND_INV_SRC_ALPHA
-#define D3D_BLEND_DEST_ALPHA        D3D12_BLEND_DEST_ALPHA
-#define D3D_BLEND_INV_DEST_ALPHA    D3D12_BLEND_INV_DEST_ALPHA
-#define D3D_BLEND_DEST_COLOR        D3D12_BLEND_DEST_COLOR
-#define D3D_BLEND_INV_DEST_COLOR    D3D12_BLEND_INV_DEST_COLOR
-#define D3D_BLEND_SRC_ALPHA_SAT     D3D12_BLEND_SRC_ALPHA_SAT
-#define D3D_BLEND_BLEND_FACTOR      D3D12_BLEND_BLEND_FACTOR
-#define D3D_BLEND_INV_BLEND_FACTOR  D3D12_BLEND_INV_BLEND_FACTOR
-#define D3D_BLEND_SRC1_COLOR        D3D12_BLEND_SRC1_COLOR
-#define D3D_BLEND_INV_SRC1_COLOR    D3D12_BLEND_INV_SRC1_COLOR
-#define D3D_BLEND_SRC1_ALPHA        D3D12_BLEND_SRC1_ALPHA
-#define D3D_BLEND_INV_SRC1_ALPHA    D3D12_BLEND_INV_SRC1_ALPHA
-
-// Blend operations
-#define D3D_BLEND_OP_ADD          D3D12_BLEND_OP_ADD
-#define D3D_BLEND_OP_SUBTRACT     D3D12_BLEND_OP_SUBTRACT
-#define D3D_BLEND_OP_REV_SUBTRACT D3D12_BLEND_OP_REV_SUBTRACT
-#define D3D_BLEND_OP_MIN          D3D12_BLEND_OP_MIN
-#define D3D_BLEND_OP_MAX          D3D12_BLEND_OP_MAX
-
-// Color masks
-#define D3D_COLOR_WRITE_ENABLE_RED      D3D12_COLOR_WRITE_ENABLE_RED
-#define D3D_COLOR_WRITE_ENABLE_GREEN    D3D12_COLOR_WRITE_ENABLE_GREEN
-#define D3D_COLOR_WRITE_ENABLE_BLUE     D3D12_COLOR_WRITE_ENABLE_BLUE
-#define D3D_COLOR_WRITE_ENABLE_ALPHA    D3D12_COLOR_WRITE_ENABLE_ALPHA
-
-// Input classification
-#define D3D_INPUT_CLASSIFICATION_PER_VERTEX_DATA   D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA
-#define D3D_INPUT_CLASSIFICATION_PER_INSTANCE_DATA D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA
-
-// Texture address modes
-#define D3D_TEXTURE_ADDRESS_WRAP        D3D12_TEXTURE_ADDRESS_MODE_WRAP
-#define D3D_TEXTURE_ADDRESS_MIRROR      D3D12_TEXTURE_ADDRESS_MODE_MIRROR
-#define D3D_TEXTURE_ADDRESS_CLAMP       D3D12_TEXTURE_ADDRESS_MODE_CLAMP
-#define D3D_TEXTURE_ADDRESS_BORDER      D3D12_TEXTURE_ADDRESS_MODE_BORDER
-#define D3D_TEXTURE_ADDRESS_MIRROR_ONCE D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE
-
-// SRV Dimensions
-#define D3D_SRV_DIMENSION_UNKNOWN             D3D12_SRV_DIMENSION_UNKNOWN
-#define D3D_SRV_DIMENSION_BUFFER              D3D12_SRV_DIMENSION_BUFFER
-#define D3D_SRV_DIMENSION_TEXTURE1D           D3D12_SRV_DIMENSION_TEXTURE1D
-#define D3D_SRV_DIMENSION_TEXTURE1DARRAY      D3D12_SRV_DIMENSION_TEXTURE1DARRAY
-#define D3D_SRV_DIMENSION_TEXTURE2D           D3D12_SRV_DIMENSION_TEXTURE2D
-#define D3D_SRV_DIMENSION_TEXTURE2DARRAY      D3D12_SRV_DIMENSION_TEXTURE2DARRAY
-#define D3D_SRV_DIMENSION_TEXTURE2DMS         D3D12_SRV_DIMENSION_TEXTURE2DMS
-#define D3D_SRV_DIMENSION_TEXTURE2DMSARRAY    D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY
-#define D3D_SRV_DIMENSION_TEXTURE3D           D3D12_SRV_DIMENSION_TEXTURE3D
-#define D3D_SRV_DIMENSION_TEXTURECUBE         D3D12_SRV_DIMENSION_TEXTURECUBE
-#define D3D_SRV_DIMENSION_TEXTURECUBEARRAY    D3D12_SRV_DIMENSION_TEXTURECUBEARRAY
-
-// RTV Dimensions 
-#define  D3D_RTV_DIMENSION_UNKNOWN          D3D12_RTV_DIMENSION_UNKNOWN
-#define  D3D_RTV_DIMENSION_BUFFER           D3D12_RTV_DIMENSION_BUFFER
-#define  D3D_RTV_DIMENSION_TEXTURE1D        D3D12_RTV_DIMENSION_TEXTURE1D
-#define  D3D_RTV_DIMENSION_TEXTURE1DARRAY   D3D12_RTV_DIMENSION_TEXTURE1DARRAY
-#define  D3D_RTV_DIMENSION_TEXTURE2D        D3D12_RTV_DIMENSION_TEXTURE2D
-#define  D3D_RTV_DIMENSION_TEXTURE2DARRAY   D3D12_RTV_DIMENSION_TEXTURE2DARRAY
-#define  D3D_RTV_DIMENSION_TEXTURE2DMS      D3D12_RTV_DIMENSION_TEXTURE2DMS
-#define  D3D_RTV_DIMENSION_TEXTURE2DMSARRAY D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY
-#define  D3D_RTV_DIMENSION_TEXTURE3D        D3D12_RTV_DIMENSION_TEXTURE3D
-
-
-// DSV Dimensions 
-#define D3D_DSV_DIMENSION_UNKNOWN           D3D12_DSV_DIMENSION_UNKNOWN
-#define D3D_DSV_DIMENSION_TEXTURE1D         D3D12_DSV_DIMENSION_TEXTURE1D
-#define D3D_DSV_DIMENSION_TEXTURE1DARRAY    D3D12_DSV_DIMENSION_TEXTURE1DARRAY
-#define D3D_DSV_DIMENSION_TEXTURE2D         D3D12_DSV_DIMENSION_TEXTURE2D
-#define D3D_DSV_DIMENSION_TEXTURE2DARRAY    D3D12_DSV_DIMENSION_TEXTURE2DARRAY
-#define D3D_DSV_DIMENSION_TEXTURE2DMS       D3D12_DSV_DIMENSION_TEXTURE2DMS
-#define D3D_DSV_DIMENSION_TEXTURE2DMSARRAY  D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY
-
-// UAV Dimensions
-#define D3D_UAV_DIMENSION_UNKNOWN           D3D12_UAV_DIMENSION_UNKNOWN
-#define D3D_UAV_DIMENSION_BUFFER            D3D12_UAV_DIMENSION_BUFFER
-#define D3D_UAV_DIMENSION_TEXTURE1D         D3D12_UAV_DIMENSION_TEXTURE1D
-#define D3D_UAV_DIMENSION_TEXTURE1DARRAY    D3D12_UAV_DIMENSION_TEXTURE1DARRAY
-#define D3D_UAV_DIMENSION_TEXTURE2D         D3D12_UAV_DIMENSION_TEXTURE2D
-#define D3D_UAV_DIMENSION_TEXTURE2DARRAY    D3D12_UAV_DIMENSION_TEXTURE2DARRAY
-#define D3D_UAV_DIMENSION_TEXTURE3D         D3D12_UAV_DIMENSION_TEXTURE3D
-#endif
\ No newline at end of file
diff --git a/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp
index 65bc8b6c..ab7d01f3 100644
--- a/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp
@@ -22,6 +22,7 @@
  */
 
 #include "pch.h"
+#include <array>
 #include "PipelineStateVkImpl.h"
 #include "ShaderVkImpl.h"
 #include "VulkanTypeConversions.h"
@@ -254,7 +255,13 @@ PipelineStateVkImpl :: PipelineStateVkImpl(IReferenceCounters *pRefCounters, Ren
                                 (GraphicsPipeline.pGS != nullptr ? 1 : 0);
         std::vector<VkPipelineShaderStageCreateInfo> Stages(PipelineCI.stageCount);
         PipelineCI.pStages = Stages.data();
-        PipelineCI.pVertexInputState;
+        
+        VkPipelineVertexInputStateCreateInfo VertexInputStateCI = {};
+        std::array<VkVertexInputBindingDescription, iMaxLayoutElements> BindingDescriptions;
+        std::array<VkVertexInputAttributeDescription, iMaxLayoutElements> AttributeDescription;
+        InputLayoutDesc_To_VkVertexInputStateCI(GraphicsPipeline.InputLayout, VertexInputStateCI, BindingDescriptions, AttributeDescription);
+        PipelineCI.pVertexInputState = &VertexInputStateCI;
+
 
         VkPipelineInputAssemblyStateCreateInfo InputAssemblyCI = {};
         InputAssemblyCI.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
diff --git a/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp b/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
index 24f7300b..943e520e 100644
--- a/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
@@ -26,7 +26,6 @@
 #include <array>
 
 #include "VulkanTypeConversions.h"
-#include "VulkanTypeDefinitions.h"
 
 namespace Diligent
 {
@@ -463,154 +462,154 @@ VkFormat TypeToVkFormat(VALUE_TYPE ValType, Uint32 NumComponents, Bool bIsNormal
 {
     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)
+        case VT_FLOAT16:
         {
+            VERIFY(!bIsNormalized, "Floating point formats cannot be normalized");
             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;
+                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;
             }
         }
-        else
+
+        case VT_FLOAT32:
         {
+            VERIFY(!bIsNormalized, "Floating point formats cannot be normalized");
             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 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_UINT16:
-    {
-        if (bIsNormalized)
+        case VT_INT32:
         {
+            VERIFY(!bIsNormalized, "32-bit UNORM formats are not supported. Use R32_FLOAT instead");
             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;
+                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;
             }
         }
-        else
+
+        case VT_UINT32:
         {
+            VERIFY(!bIsNormalized, "32-bit UNORM formats are not supported. Use R32_FLOAT instead");
             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 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_INT8:
-    {
-        if (bIsNormalized)
+        case VT_INT16:
         {
-            switch (NumComponents)
+            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
             {
-            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;
+                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;
+                }
             }
         }
-        else
+
+        case VT_UINT16:
         {
-            switch (NumComponents)
+            if (bIsNormalized)
             {
-            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;
+                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_UINT8:
-    {
-        if (bIsNormalized)
+        case VT_INT8:
         {
-            switch (NumComponents)
+            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
             {
-            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;
+                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;
+                }
             }
         }
-        else
+
+        case VT_UINT8:
         {
-            switch (NumComponents)
+            if (bIsNormalized)
             {
-            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;
+                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;
+        default: UNEXPECTED("Unusupported format"); return VK_FORMAT_UNDEFINED;
     }
 }
 
@@ -910,6 +909,64 @@ void BlendStateDesc_To_VkBlendStateCI(const BlendStateDesc &BSDesc,
     }
 }
 
+VkVertexInputRate LayoutElemFrequencyToVkInputRate(LayoutElement::FREQUENCY frequency)
+{
+    switch(frequency)
+    {
+        case LayoutElement::FREQUENCY_UNDEFINED: 
+            UNEXPECTED("Undefined layout element frequency");
+            return VK_VERTEX_INPUT_RATE_VERTEX;
+        
+        case LayoutElement::FREQUENCY_PER_VERTEX:   return VK_VERTEX_INPUT_RATE_VERTEX;
+        case LayoutElement::FREQUENCY_PER_INSTANCE: return VK_VERTEX_INPUT_RATE_INSTANCE;
+
+        default:
+            UNEXPECTED("Unknown layout element frequency");
+            return VK_VERTEX_INPUT_RATE_VERTEX;
+    }
+}
+
+void InputLayoutDesc_To_VkVertexInputStateCI(const InputLayoutDesc& LayoutDesc,
+                                             VkPipelineVertexInputStateCreateInfo &VertexInputStateCI,
+                                             std::array<VkVertexInputBindingDescription, iMaxLayoutElements>& BindingDescriptions,
+                                             std::array<VkVertexInputAttributeDescription, iMaxLayoutElements>& AttributeDescription)
+{
+    // Vertex input description (20.2)
+    VertexInputStateCI.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+    VertexInputStateCI.pNext = nullptr;
+    VertexInputStateCI.flags = 0; // reserved for future use.
+    VertexInputStateCI.vertexBindingDescriptionCount = 0;
+    VertexInputStateCI.pVertexBindingDescriptions = BindingDescriptions.data();
+    VertexInputStateCI.vertexAttributeDescriptionCount = LayoutDesc.NumElements;
+    VertexInputStateCI.pVertexAttributeDescriptions = AttributeDescription.data();
+    std::array<Int32, iMaxLayoutElements> BufferSlot2BindingDescInd;
+    BufferSlot2BindingDescInd.fill(-1);
+    for(Uint32 elem=0; elem < LayoutDesc.NumElements; ++elem)
+    {
+        auto &LayoutElem = LayoutDesc.LayoutElements[elem];
+        auto &BindingDescInd = BufferSlot2BindingDescInd[LayoutElem.BufferSlot];
+        if(BindingDescInd < 0)
+        {
+            BindingDescInd = VertexInputStateCI.vertexBindingDescriptionCount++;
+            auto &BindingDesc = BindingDescriptions[BindingDescInd];
+            BindingDesc.binding = LayoutElem.BufferSlot;
+            //BindingDesc.stride = LayoutElem.
+            BindingDesc.inputRate = LayoutElemFrequencyToVkInputRate(LayoutElem.Frequency);
+        }
+
+        const auto &BindingDesc = BindingDescriptions[BindingDescInd];
+        VERIFY(BindingDesc.binding == LayoutElem.BufferSlot, "Inconsistent buffer slot");
+        VERIFY(BindingDesc.inputRate == LayoutElemFrequencyToVkInputRate(LayoutElem.Frequency), "Incosistent layout element frequency");
+
+        auto &AttribDesc = AttributeDescription[elem];
+        AttribDesc.binding = BindingDesc.binding;
+        AttribDesc.location = LayoutElem.InputIndex;
+        AttribDesc.format = TypeToVkFormat(LayoutElem.ValueType, LayoutElem.NumComponents, LayoutElem.IsNormalized);
+        AttribDesc.offset = LayoutElem.RelativeOffset;
+    }
+
+}
+
 
 #if 0
 D3D12_COMPARISON_FUNC ComparisonFuncToD3D12ComparisonFunc(COMPARISON_FUNCTION Func)