Vulkan: use host_image_copy extension to initialize textures (API256006, close #655)

Author: TheMostDiligent

Graphics/GraphicsEngine/interface/APIInfo.h

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2024 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -30,7 +30,7 @@
 /// \file
 /// Diligent API information
 
-#define DILIGENT_API_VERSION 256005
+#define DILIGENT_API_VERSION 256006
 
 #include "../../../Primitives/interface/BasicTypes.h"
 

Graphics/GraphicsEngine/interface/GraphicsTypes.h

@@ -3940,16 +3940,23 @@ struct DeviceFeaturesVk
     ///             using framebuffer and render pass caches.
     DEVICE_FEATURE_STATE DynamicRendering DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
 
+    /// Indicates whether the device supports VK_EXT_host_image_copy extension.
+    ///
+    /// \remarks    This extension is used to initialize the texture on the host.
+    ///             If the extension is not supported, the texture is initialized on the device.
+    DEVICE_FEATURE_STATE HostImageCopy DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
+
 
 #if DILIGENT_CPP_INTERFACE
     constexpr DeviceFeaturesVk() noexcept {}
 
 #define ENUMERATE_VK_DEVICE_FEATURES(Handler) \
-    Handler(DynamicRendering)
+    Handler(DynamicRendering) \
+    Handler(HostImageCopy)
 
     explicit constexpr DeviceFeaturesVk(DEVICE_FEATURE_STATE State) noexcept
     {
-        static_assert(sizeof(*this) == 1, "Did you add a new feature to DeviceFeatures? Please add it to ENUMERATE_DEVICE_FEATURES.");
+        static_assert(sizeof(*this) == 2, "Did you add a new feature to DeviceFeatures? Please add it to ENUMERATE_VK_DEVICE_FEATURES.");
     #define INIT_FEATURE(Feature) Feature = State;
         ENUMERATE_VK_DEVICE_FEATURES(INIT_FEATURE)
     #undef INIT_FEATURE

Graphics/GraphicsEngine/src/RenderDeviceBase.cpp

@@ -133,8 +133,9 @@ DeviceFeaturesVk EnableDeviceFeaturesVk(const DeviceFeaturesVk& SupportedFeature
     DeviceFeaturesVk EnabledFeatures;
 
     ENABLE_FEATURE(DynamicRendering, "VK_KHR_dynamic_rendering is");
+    ENABLE_FEATURE(HostImageCopy, "VK_EXT_host_image_copy is");
 
-    ASSERT_SIZEOF(DeviceFeaturesVk, 1, "Did you add a new feature to DeviceFeaturesVk? Please handle its status here (if necessary).");
+    ASSERT_SIZEOF(DeviceFeaturesVk, 2, "Did you add a new feature to DeviceFeaturesVk? Please handle its status here (if necessary).");
 
     return EnabledFeatures;
 }

Graphics/GraphicsEngineVulkan/include/TextureVkImpl.hpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2023 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -101,9 +101,13 @@ class TextureVkImpl final : public TextureBase<EngineVkImplTraits>
 protected:
     void CreateViewInternal(const struct TextureViewDesc& ViewDesc, ITextureView** ppView, bool bIsDefaultView) override;
 
-    void InitializeTextureContent(const TextureData&          InitData,
-                                  const TextureFormatAttribs& FmtAttribs,
-                                  const VkImageCreateInfo&    ImageCI) noexcept(false);
+    void InitializeContentOnDevice(const TextureData&          InitData,
+                                   const TextureFormatAttribs& FmtAttribs,
+                                   const VkImageCreateInfo&    ImageCI) noexcept(false);
+    bool InitializeContentOnHost(const TextureData&          InitData,
+                                 const TextureFormatAttribs& FmtAttribs,
+                                 const VkImageCreateInfo&    ImageCI) noexcept(false);
+
     void CreateStagingTexture(const TextureData*          pInitData,
                               const TextureFormatAttribs& FmtAttribs);
 
@@ -117,6 +121,4 @@ class TextureVkImpl final : public TextureBase<EngineVkImplTraits>
     VkDeviceSize                            m_StagingDataAlignedOffset = 0;
 };
 
-VkImageCreateInfo TextureDescToVkImageCreateInfo(const TextureDesc& Desc, const RenderDeviceVkImpl* pDevice) noexcept;
-
 } // namespace Diligent

Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanLogicalDevice.hpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2024 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -237,6 +237,9 @@ class VulkanLogicalDevice : public std::enable_shared_from_this<VulkanLogicalDev
                         uint32_t    firstQuery,
                         uint32_t    queryCount) const;
 
+    VkResult CopyMemoryToImage(const VkCopyMemoryToImageInfoEXT& CopyInfo) const;
+    VkResult HostTransitionImageLayout(const VkHostImageLayoutTransitionInfoEXT& TransitionInfo) const;
+
     void GetAccelerationStructureBuildSizes(const VkAccelerationStructureBuildGeometryInfoKHR& BuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR& SizeInfo) const;
 
     VkResult GetRayTracingShaderGroupHandles(VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const;

Graphics/GraphicsEngineVulkan/include/VulkanUtilities/VulkanPhysicalDevice.hpp

@@ -68,6 +68,8 @@ class VulkanPhysicalDevice
         VkPhysicalDeviceMultiDrawFeaturesEXT              MultiDraw              = {};
         VkPhysicalDeviceShaderDrawParametersFeatures      ShaderDrawParameters   = {};
         VkPhysicalDeviceDynamicRenderingFeaturesKHR       DynamicRendering       = {};
+        VkPhysicalDeviceHostImageCopyFeaturesEXT          HostImageCopy          = {};
+
 
         bool Spirv14              = false; // Ray tracing requires Vulkan 1.2 or SPIRV 1.4 extension
         bool Spirv15              = false; // DXC shaders with ray tracing requires Vulkan 1.2 with SPIRV 1.5
@@ -93,6 +95,9 @@ class VulkanPhysicalDevice
         VkPhysicalDeviceMaintenance3Properties              Maintenance3           = {};
         VkPhysicalDeviceFragmentDensityMap2PropertiesEXT    FragmentDensityMap2    = {};
         VkPhysicalDeviceMultiDrawPropertiesEXT              MultiDraw              = {};
+        VkPhysicalDeviceHostImageCopyPropertiesEXT          HostImageCopy          = {};
+
+        std::unique_ptr<VkImageLayout[]> HostImageCopyLayouts;
     };
 
 public:
@@ -121,7 +126,7 @@ class VulkanPhysicalDevice
     const ExtensionFeatures&                    GetExtFeatures() const { return m_ExtFeatures; }
     const ExtensionProperties&                  GetExtProperties() const { return m_ExtProperties; }
     const VkPhysicalDeviceMemoryProperties&     GetMemoryProperties() const { return m_MemoryProperties; }
-    VkFormatProperties                          GetPhysicalDeviceFormatProperties(VkFormat imageFormat) const;
+    VkFormatProperties                          GetPhysicalDeviceFormatProperties(VkFormat imageFormat, VkFormatProperties3* Properties3 = nullptr) const;
     const std::vector<VkQueueFamilyProperties>& GetQueueProperties() const { return m_QueueFamilyProperties; }
 
 private:

Graphics/GraphicsEngineVulkan/src/EngineFactoryVk.cpp

@@ -1246,6 +1246,17 @@ void EngineFactoryVkImpl::CreateDeviceAndContextsVk(const EngineVkCreateInfo& En
                 NextExt  = &EnabledExtFeats.DynamicRendering.pNext;
             }
 
+            if (EnabledFeaturesVk.HostImageCopy)
+            {
+                VERIFY_EXPR(PhysicalDevice->IsExtensionSupported(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME));
+                DeviceExtensions.push_back(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME);
+
+                EnabledExtFeats.HostImageCopy = DeviceExtFeatures.HostImageCopy;
+
+                *NextExt = &EnabledExtFeats.HostImageCopy;
+                NextExt  = &EnabledExtFeats.HostImageCopy.pNext;
+            }
+
             // Append user-defined features
             *NextExt = EngineCI.pDeviceExtensionFeatures;
         }

Graphics/GraphicsEngineVulkan/src/TextureVkImpl.cpp

@@ -38,6 +38,9 @@
 namespace Diligent
 {
 
+namespace
+{
+
 VkImageCreateInfo TextureDescToVkImageCreateInfo(const TextureDesc& Desc, const RenderDeviceVkImpl* pRenderDeviceVk) noexcept
 {
     const bool                  IsMemoryless         = (Desc.MiscFlags & MISC_TEXTURE_FLAG_MEMORYLESS) != 0;
@@ -143,6 +146,59 @@ VkImageCreateInfo TextureDescToVkImageCreateInfo(const TextureDesc& Desc, const
     return ImageCI;
 }
 
+VkImageLayout VkImageLayoutFromUsage(VkImageUsageFlags Usage)
+{
+    if ((Usage & (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) != 0)
+        return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+
+    if ((Usage & VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT) != 0)
+        return VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT;
+
+    if ((Usage & VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) != 0)
+        return VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
+
+    if ((Usage & VK_IMAGE_USAGE_STORAGE_BIT) != 0)
+        return VK_IMAGE_LAYOUT_GENERAL;
+
+    if ((Usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) != 0)
+        return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+    if ((Usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0)
+        return VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
+
+    VERIFY((Usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) != 0, "TRANSFER_SRC_BIT should always be set");
+    return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+}
+
+bool CheckHostImageCopySupport(const VulkanUtilities::VulkanLogicalDevice&  LogicalDevice,
+                               const VulkanUtilities::VulkanPhysicalDevice& PhysicalDevice,
+                               const VkImageCreateInfo&                     ImageCI)
+{
+    if (!LogicalDevice.GetEnabledExtFeatures().HostImageCopy.hostImageCopy)
+        return false;
+
+    VkFormatProperties3 vkFormatProps3{};
+    VkFormatProperties  VkFormatProps = PhysicalDevice.GetPhysicalDeviceFormatProperties(ImageCI.format, &vkFormatProps3);
+
+    if ((vkFormatProps3.optimalTilingFeatures & VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT) == 0)
+        return false;
+
+    const VulkanUtilities::VulkanPhysicalDevice::ExtensionProperties& ExtProps           = PhysicalDevice.GetExtProperties();
+    const VkPhysicalDeviceHostImageCopyPropertiesEXT&                 HostImageCopyProps = ExtProps.HostImageCopy;
+
+    const VkImageLayout DstLayout = VkImageLayoutFromUsage(ImageCI.usage);
+
+    auto LayoutSupported = [](const VkImageLayout* pLayouts, uint32_t LayoutCount, VkImageLayout Layout) {
+        return std::find(pLayouts, pLayouts + LayoutCount, Layout) != pLayouts + LayoutCount;
+    };
+
+    if (!LayoutSupported(HostImageCopyProps.pCopyDstLayouts, HostImageCopyProps.copyDstLayoutCount, DstLayout))
+        return false;
+
+    return true;
+}
+
+} // namespace
 
 TextureVkImpl::TextureVkImpl(IReferenceCounters*        pRefCounters,
                              FixedBlockMemoryAllocator& TexViewObjAllocator,
@@ -179,6 +235,11 @@ TextureVkImpl::TextureVkImpl(IReferenceCounters*        pRefCounters,
 
         VkImageCreateInfo ImageCI = TextureDescToVkImageCreateInfo(m_Desc, pRenderDeviceVk);
 
+        const bool InitContent      = pInitData != nullptr && pInitData->pSubResources != nullptr && pInitData->NumSubresources > 0;
+        const bool UseHostImageCopy = InitContent && CheckHostImageCopySupport(LogicalDevice, pRenderDeviceVk->GetPhysicalDevice(), ImageCI);
+        if (UseHostImageCopy)
+            ImageCI.usage |= VK_IMAGE_USAGE_HOST_TRANSFER_BIT;
+
         const std::vector<uint32_t> QueueFamilyIndices = PlatformMisc::CountOneBits(m_Desc.ImmediateContextMask) > 1 ?
             GetDevice()->ConvertCmdQueueIdsToQueueFamilies(m_Desc.ImmediateContextMask) :
             std::vector<uint32_t>{};
@@ -223,10 +284,23 @@ TextureVkImpl::TextureVkImpl(IReferenceCounters*        pRefCounters,
             VkResult       err    = LogicalDevice.BindImageMemory(m_VulkanImage, Memory, AlignedOffset);
             CHECK_VK_ERROR_AND_THROW(err, "Failed to bind image memory");
 
-            if (pInitData != nullptr && pInitData->pSubResources != nullptr && pInitData->NumSubresources > 0)
-                InitializeTextureContent(*pInitData, FmtAttribs, ImageCI);
+            if (InitContent)
+            {
+                bool InitializedOnHost = false;
+                if (UseHostImageCopy)
+                {
+                    InitializedOnHost = InitializeContentOnHost(*pInitData, FmtAttribs, ImageCI);
+                }
+
+                if (!InitializedOnHost)
+                {
+                    InitializeContentOnDevice(*pInitData, FmtAttribs, ImageCI);
+                }
+            }
             else
+            {
                 SetState(RESOURCE_STATE_UNDEFINED);
+            }
         }
     }
     else if (m_Desc.Usage == USAGE_STAGING)
@@ -241,9 +315,100 @@ TextureVkImpl::TextureVkImpl(IReferenceCounters*        pRefCounters,
     VERIFY_EXPR(IsInKnownState());
 }
 
-void TextureVkImpl::InitializeTextureContent(const TextureData&          InitData,
-                                             const TextureFormatAttribs& FmtAttribs,
-                                             const VkImageCreateInfo&    ImageCI) noexcept(false)
+bool TextureVkImpl::InitializeContentOnHost(const TextureData&          InitData,
+                                            const TextureFormatAttribs& FmtAttribs,
+                                            const VkImageCreateInfo&    ImageCI) noexcept(false)
+{
+    const VulkanUtilities::VulkanLogicalDevice& LogicalDevice = GetDevice()->GetLogicalDevice();
+    VERIFY_EXPR(LogicalDevice.GetEnabledExtFeatures().HostImageCopy.hostImageCopy);
+
+    Uint32 ExpectedNumSubresources = ImageCI.mipLevels * ImageCI.arrayLayers;
+    if (InitData.NumSubresources != ExpectedNumSubresources)
+        LOG_ERROR_AND_THROW("Incorrect number of subresources in init data. ", ExpectedNumSubresources, " expected, while ", InitData.NumSubresources, " provided");
+
+    VERIFY(FmtAttribs.ComponentType != COMPONENT_TYPE_DEPTH_STENCIL, "Initializing depth-stencil texture is currently not supported.");
+    const VkImageAspectFlags aspectMask = ComponentTypeToVkAspectMask(FmtAttribs.ComponentType);
+
+    std::vector<VkMemoryToImageCopyEXT> vkCopyRegions(InitData.NumSubresources);
+
+    Uint32 subres = 0;
+    for (Uint32 layer = 0; layer < ImageCI.arrayLayers; ++layer)
+    {
+        for (Uint32 mip = 0; mip < ImageCI.mipLevels; ++mip)
+        {
+            const TextureSubResData& SubResData = InitData.pSubResources[subres];
+            VkMemoryToImageCopyEXT&  vkCopyInfo = vkCopyRegions[subres];
+            MipLevelProperties       MipInfo    = GetMipLevelProperties(m_Desc, mip);
+
+            vkCopyInfo.sType        = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT;
+            vkCopyInfo.pNext        = nullptr;
+            vkCopyInfo.pHostPointer = SubResData.pData;
+
+            const Uint32 PixelSize = FmtAttribs.ComponentType == COMPONENT_TYPE_COMPRESSED ?
+                Uint32{FmtAttribs.ComponentSize} :
+                Uint32{FmtAttribs.ComponentSize} * Uint32{FmtAttribs.NumComponents};
+            if ((SubResData.Stride % PixelSize) != 0)
+            {
+                LOG_DVP_WARNING_MESSAGE("Unable to initialize texture '", m_Desc.Name, "' on host: subresource ", subres, " has stride ", SubResData.Stride,
+                                        " that is not multiple of pixel size ", PixelSize, ". The content will be initialized on device.");
+                return false;
+            }
+            vkCopyInfo.memoryRowLength = FmtAttribs.ComponentType == COMPONENT_TYPE_COMPRESSED ?
+                static_cast<uint32_t>(SubResData.Stride * FmtAttribs.BlockWidth / FmtAttribs.ComponentSize) :
+                static_cast<uint32_t>(SubResData.Stride / PixelSize);
+
+            if ((SubResData.DepthStride % SubResData.Stride) != 0)
+            {
+                LOG_DVP_WARNING_MESSAGE("Unable to initialize texture '", m_Desc.Name, "' on host: subresource ", subres, " has depth stride ", SubResData.DepthStride,
+                                        " that is not multiple of row stride ", SubResData.Stride, ". The content will be initialized on device.");
+                return false;
+            }
+            vkCopyInfo.memoryImageHeight = static_cast<uint32_t>(SubResData.DepthStride * FmtAttribs.BlockHeight / SubResData.Stride);
+
+            vkCopyInfo.imageSubresource.aspectMask     = aspectMask;
+            vkCopyInfo.imageSubresource.mipLevel       = mip;
+            vkCopyInfo.imageSubresource.baseArrayLayer = layer;
+            vkCopyInfo.imageSubresource.layerCount     = 1;
+
+            vkCopyInfo.imageOffset = {0, 0, 0};
+            vkCopyInfo.imageExtent = {MipInfo.LogicalWidth, MipInfo.LogicalHeight, MipInfo.Depth};
+
+            ++subres;
+        }
+    }
+
+    VkHostImageLayoutTransitionInfoEXT vkLayoutTransitionInfo{};
+    vkLayoutTransitionInfo.sType     = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT;
+    vkLayoutTransitionInfo.image     = m_VulkanImage;
+    vkLayoutTransitionInfo.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+    vkLayoutTransitionInfo.newLayout = VkImageLayoutFromUsage(ImageCI.usage);
+
+    vkLayoutTransitionInfo.subresourceRange.aspectMask     = aspectMask;
+    vkLayoutTransitionInfo.subresourceRange.baseArrayLayer = 0;
+    vkLayoutTransitionInfo.subresourceRange.layerCount     = VK_REMAINING_ARRAY_LAYERS;
+    vkLayoutTransitionInfo.subresourceRange.baseMipLevel   = 0;
+    vkLayoutTransitionInfo.subresourceRange.levelCount     = VK_REMAINING_MIP_LEVELS;
+    LogicalDevice.HostTransitionImageLayout(vkLayoutTransitionInfo);
+
+    VkCopyMemoryToImageInfoEXT vkCopyInfo{};
+    vkCopyInfo.sType          = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT;
+    vkCopyInfo.pNext          = nullptr;
+    vkCopyInfo.flags          = 0;
+    vkCopyInfo.dstImage       = m_VulkanImage;
+    vkCopyInfo.dstImageLayout = vkLayoutTransitionInfo.newLayout;
+    vkCopyInfo.regionCount    = static_cast<uint32_t>(vkCopyRegions.size());
+    vkCopyInfo.pRegions       = vkCopyRegions.data();
+
+    LogicalDevice.CopyMemoryToImage(vkCopyInfo);
+
+    SetState(VkImageLayoutToResourceState(vkCopyInfo.dstImageLayout));
+
+    return true;
+}
+
+void TextureVkImpl::InitializeContentOnDevice(const TextureData&          InitData,
+                                              const TextureFormatAttribs& FmtAttribs,
+                                              const VkImageCreateInfo&    ImageCI) noexcept(false)
 {
     const VulkanUtilities::VulkanLogicalDevice& LogicalDevice = GetDevice()->GetLogicalDevice();
 
@@ -258,18 +423,8 @@ void TextureVkImpl::InitializeTextureContent(const TextureData&          InitDat
     VulkanUtilities::VulkanCommandBuffer CmdBuffer;
     GetDevice()->AllocateTransientCmdPool(CmdQueueInd, CmdPool, CmdBuffer, "Transient command pool to copy staging data to a device buffer");
 
-    VkImageAspectFlags aspectMask = 0;
-    if (FmtAttribs.ComponentType == COMPONENT_TYPE_DEPTH)
-        aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
-    else if (FmtAttribs.ComponentType == COMPONENT_TYPE_DEPTH_STENCIL)
-    {
-        UNSUPPORTED("Initializing depth-stencil texture is not currently supported");
-        // Only single aspect bit must be specified when copying texture data
-
-        aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
-    }
-    else
-        aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    VERIFY(FmtAttribs.ComponentType != COMPONENT_TYPE_DEPTH_STENCIL, "Initializing depth-stencil texture is currently not supported.");
+    const VkImageAspectFlags aspectMask = ComponentTypeToVkAspectMask(FmtAttribs.ComponentType);
 
     // For either clear or copy command, dst layout must be VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
     VkImageSubresourceRange SubresRange;

Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp

@@ -2063,10 +2063,11 @@ DeviceFeaturesVk PhysicalDeviceFeaturesToDeviceFeaturesVk(const VulkanUtilities:
     FeaturesVk.FeatureName = (Supported) ? OptionalState : DEVICE_FEATURE_STATE_DISABLED
 
     INIT_FEATURE(DynamicRendering, ExtFeatures.DynamicRendering.dynamicRendering != VK_FALSE);
+    INIT_FEATURE(HostImageCopy, ExtFeatures.HostImageCopy.hostImageCopy != VK_FALSE);
 
 #undef INIT_FEATURE
 
-    ASSERT_SIZEOF(DeviceFeaturesVk, 1, "Did you add a new feature to DeviceFeaturesVk? Please handle its status here (if necessary).");
+    ASSERT_SIZEOF(DeviceFeaturesVk, 2, "Did you add a new feature to DeviceFeaturesVk? Please handle its status here (if necessary).");
 
     return FeaturesVk;
 }