Added DeviceFeaturesVk struct (API256004)

TheMostDiligent · TheMostDiligent · commit d67e5267699e · 2025-02-05T09:45:26.000-08:00
diff --git a/Graphics/GraphicsEngine/include/RenderDeviceBase.hpp b/Graphics/GraphicsEngine/include/RenderDeviceBase.hpp
@@ -72,6 +72,9 @@ namespace Diligent
 DeviceFeatures EnableDeviceFeatures(const DeviceFeatures& SupportedFeatures,
                                     const DeviceFeatures& RequestedFeatures) noexcept(false);
 
+DeviceFeaturesVk EnableDeviceFeaturesVk(const DeviceFeaturesVk& SupportedFeatures,
+                                        const DeviceFeaturesVk& RequestedFeatures) noexcept(false);
+
 /// Checks sparse texture format support and returns the component type
 COMPONENT_TYPE CheckSparseTextureFormatSupport(TEXTURE_FORMAT                  TexFormat,
                                                RESOURCE_DIMENSION              Dimension,
diff --git a/Graphics/GraphicsEngine/interface/APIInfo.h b/Graphics/GraphicsEngine/interface/APIInfo.h
@@ -30,7 +30,7 @@
 /// \file
 /// Diligent API information
 
-#define DILIGENT_API_VERSION 256003
+#define DILIGENT_API_VERSION 256004
 
 #include "../../../Primitives/interface/BasicTypes.h"
 
diff --git a/Graphics/GraphicsEngine/interface/GraphicsTypes.h b/Graphics/GraphicsEngine/interface/GraphicsTypes.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");
@@ -3931,9 +3931,57 @@ struct VulkanDescriptorPoolSize
 typedef struct VulkanDescriptorPoolSize VulkanDescriptorPoolSize;
 
 
+/// Vulkan-specific device features
+struct DeviceFeaturesVk
+{
+    /// Indicates whether the device supports VK_KHR_dynamic_rendering extension.
+    ///
+    /// \remarks    If the extension is not supported, dynamic render targets are implemented
+    ///             using framebuffer and render pass caches.
+    DEVICE_FEATURE_STATE DynamicRendering DEFAULT_INITIALIZER(DEVICE_FEATURE_STATE_DISABLED);
+
+
+#if DILIGENT_CPP_INTERFACE
+    constexpr DeviceFeaturesVk() noexcept {}
+
+#define ENUMERATE_VK_DEVICE_FEATURES(Handler) \
+    Handler(DynamicRendering)
+
+    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.");
+    #define INIT_FEATURE(Feature) Feature = State;
+        ENUMERATE_VK_DEVICE_FEATURES(INIT_FEATURE)
+    #undef INIT_FEATURE
+    }
+
+    template <typename FeatType, typename HandlerType>
+    static void Enumerate(FeatType& Features, HandlerType&& Handler)
+    {
+    #define HandleFeature(Feature)                \
+        if (!Handler(#Feature, Features.Feature)) \
+            return;
+
+        ENUMERATE_VK_DEVICE_FEATURES(HandleFeature)
+
+    #undef HandleFeature
+    }
+
+    /// Comparison operator tests if two structures are equivalent
+    bool operator == (const DeviceFeatures& RHS) const
+    {
+        return memcmp(this, &RHS, sizeof(DeviceFeatures)) == 0;
+    }
+#endif
+};
+typedef struct DeviceFeaturesVk DeviceFeaturesVk;
+
 /// Attributes specific to Vulkan engine
 struct EngineVkCreateInfo DILIGENT_DERIVE(EngineCreateInfo)
 
+    /// Vulkan-specific device features, see Diligent::DeviceFeaturesVk.
+    DeviceFeaturesVk   FeaturesVk;
+
     /// The number of Vulkan instance layers in ppInstanceLayerNames array.
     Uint32             InstanceLayerCount       DEFAULT_INITIALIZER(0);
 
@@ -4113,7 +4161,8 @@ struct EngineVkCreateInfo DILIGENT_DERIVE(EngineCreateInfo)
     {}
 
     explicit EngineVkCreateInfo(const EngineCreateInfo &EngineCI) noexcept :
-        EngineCreateInfo{EngineCI}
+        EngineCreateInfo{EngineCI},
+        FeaturesVk{DEVICE_FEATURE_STATE_OPTIONAL}
     {}
 #endif
 };
diff --git a/Graphics/GraphicsEngine/src/RenderDeviceBase.cpp b/Graphics/GraphicsEngine/src/RenderDeviceBase.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2024 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -30,46 +30,47 @@
 namespace Diligent
 {
 
-DeviceFeatures EnableDeviceFeatures(const DeviceFeatures& SupportedFeatures,
-                                    const DeviceFeatures& RequestedFeatures) noexcept(false)
+static DEVICE_FEATURE_STATE GetFeatureState(DEVICE_FEATURE_STATE RequestedState, DEVICE_FEATURE_STATE SupportedState, const char* FeatureName) noexcept(false)
 {
-    auto GetFeatureState = [](DEVICE_FEATURE_STATE RequestedState, DEVICE_FEATURE_STATE SupportedState, const char* FeatureName) //
+    switch (RequestedState)
     {
-        switch (RequestedState)
+        case DEVICE_FEATURE_STATE_DISABLED:
+            return SupportedState == DEVICE_FEATURE_STATE_ENABLED ?
+                DEVICE_FEATURE_STATE_ENABLED : // the feature is supported by default and can not be disabled
+                DEVICE_FEATURE_STATE_DISABLED;
+
+        case DEVICE_FEATURE_STATE_ENABLED:
         {
-            case DEVICE_FEATURE_STATE_DISABLED:
-                return SupportedState == DEVICE_FEATURE_STATE_ENABLED ?
-                    DEVICE_FEATURE_STATE_ENABLED : // the feature is supported by default and can not be disabled
-                    DEVICE_FEATURE_STATE_DISABLED;
-
-            case DEVICE_FEATURE_STATE_ENABLED:
-            {
-                if (SupportedState != DEVICE_FEATURE_STATE_DISABLED)
-                    return DEVICE_FEATURE_STATE_ENABLED;
-                else
-                    LOG_ERROR_AND_THROW(FeatureName, " not supported by this device");
-            }
-
-            case DEVICE_FEATURE_STATE_OPTIONAL:
-                return SupportedState != DEVICE_FEATURE_STATE_DISABLED ?
-                    DEVICE_FEATURE_STATE_ENABLED :
-                    DEVICE_FEATURE_STATE_DISABLED;
-
-            default:
-                UNEXPECTED("Unexpected feature state");
-                return DEVICE_FEATURE_STATE_DISABLED;
+            if (SupportedState != DEVICE_FEATURE_STATE_DISABLED)
+                return DEVICE_FEATURE_STATE_ENABLED;
+            else
+                LOG_ERROR_AND_THROW(FeatureName, " not supported by this device");
         }
-    };
 
+        case DEVICE_FEATURE_STATE_OPTIONAL:
+            return SupportedState != DEVICE_FEATURE_STATE_DISABLED ?
+                DEVICE_FEATURE_STATE_ENABLED :
+                DEVICE_FEATURE_STATE_DISABLED;
+
+        default:
+            UNEXPECTED("Unexpected feature state");
+            return DEVICE_FEATURE_STATE_DISABLED;
+    }
+};
+
+#define ENABLE_FEATURE(Feature, FeatureName) \
+    EnabledFeatures.Feature = GetFeatureState(RequestedFeatures.Feature, SupportedFeatures.Feature, FeatureName)
+
+DeviceFeatures EnableDeviceFeatures(const DeviceFeatures& SupportedFeatures,
+                                    const DeviceFeatures& RequestedFeatures) noexcept(false)
+{
     if (SupportedFeatures.SeparablePrograms == DEVICE_FEATURE_STATE_ENABLED &&
         RequestedFeatures.SeparablePrograms == DEVICE_FEATURE_STATE_DISABLED)
     {
         LOG_INFO_MESSAGE("Can not disable SeparablePrograms");
     }
 
     DeviceFeatures EnabledFeatures;
-#define ENABLE_FEATURE(Feature, FeatureName) \
-    EnabledFeatures.Feature = GetFeatureState(RequestedFeatures.Feature, SupportedFeatures.Feature, FeatureName)
 
     // clang-format off
     ENABLE_FEATURE(SeparablePrograms,                 "Separable programs are");
@@ -120,13 +121,26 @@ DeviceFeatures EnableDeviceFeatures(const DeviceFeatures& SupportedFeatures,
     ENABLE_FEATURE(AsyncShaderCompilation,            "Async shader compilation is");
     ENABLE_FEATURE(FormattedBuffers,                  "Formatted buffers are");
     // clang-format on
-#undef ENABLE_FEATURE
 
     ASSERT_SIZEOF(DeviceFeatures, 47, "Did you add a new feature to DeviceFeatures? Please handle its status here (if necessary).");
 
     return EnabledFeatures;
 }
 
+DeviceFeaturesVk EnableDeviceFeaturesVk(const DeviceFeaturesVk& SupportedFeatures,
+                                        const DeviceFeaturesVk& RequestedFeatures) noexcept(false)
+{
+    DeviceFeaturesVk EnabledFeatures;
+
+    ENABLE_FEATURE(DynamicRendering, "VK_KHR_dynamic_rendering is");
+
+    ASSERT_SIZEOF(DeviceFeaturesVk, 1, "Did you add a new feature to DeviceFeaturesVk? Please handle its status here (if necessary).");
+
+    return EnabledFeatures;
+}
+
+#undef ENABLE_FEATURE
+
 COMPONENT_TYPE CheckSparseTextureFormatSupport(TEXTURE_FORMAT                  TexFormat,
                                                RESOURCE_DIMENSION              Dimension,
                                                Uint32                          SampleCount,
diff --git a/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.hpp b/Graphics/GraphicsEngineVulkan/include/VulkanTypeConversions.hpp
@@ -112,6 +112,9 @@ DeviceFeatures VkFeaturesToDeviceFeatures(uint32_t
                                           const VulkanUtilities::VulkanPhysicalDevice::ExtensionProperties& ExtProps,
                                           DEVICE_FEATURE_STATE                                              OptionalState = DEVICE_FEATURE_STATE_ENABLED);
 
+DeviceFeaturesVk PhysicalDeviceFeaturesToDeviceFeaturesVk(const VulkanUtilities::VulkanPhysicalDevice::ExtensionFeatures& ExtFeatures,
+                                                          DEVICE_FEATURE_STATE                                            OptionalState);
+
 SPARSE_TEXTURE_FLAGS VkSparseImageFormatFlagsToSparseTextureFlags(VkSparseImageFormatFlags Flags);
 
 VkImageUsageFlags BindFlagsToVkImageUsage(BIND_FLAGS Flags, bool IsMemoryless, bool FragDensityMapInsteadOfShadingRate);
diff --git a/Graphics/GraphicsEngineVulkan/src/EngineFactoryVk.cpp b/Graphics/GraphicsEngineVulkan/src/EngineFactoryVk.cpp
@@ -752,7 +752,9 @@ void EngineFactoryVkImpl::CreateDeviceAndContextsVk(const EngineVkCreateInfo& En
         // Enable device features if they are supported and throw an error if not supported, but required by user.
         const GraphicsAdapterInfo AdapterInfo = GetPhysicalDeviceGraphicsAdapterInfo(*PhysicalDevice);
         VerifyEngineCreateInfo(EngineCI, AdapterInfo);
-        const DeviceFeatures EnabledFeatures = EnableDeviceFeatures(AdapterInfo.Features, EngineCI.Features);
+        const DeviceFeatures   EnabledFeatures   = EnableDeviceFeatures(AdapterInfo.Features, EngineCI.Features);
+        const DeviceFeaturesVk AdapterFeaturesVk = PhysicalDeviceFeaturesToDeviceFeaturesVk(PhysicalDevice->GetExtFeatures(), DEVICE_FEATURE_STATE_ENABLED);
+        const DeviceFeaturesVk EnabledFeaturesVk = EnableDeviceFeaturesVk(AdapterFeaturesVk, EngineCI.FeaturesVk);
 
         std::vector<VkDeviceQueueGlobalPriorityCreateInfoEXT> QueueGlobalPriority;
         std::vector<VkDeviceQueueCreateInfo>                  QueueInfos;
@@ -1233,6 +1235,17 @@ void EngineFactoryVkImpl::CreateDeviceAndContextsVk(const EngineVkCreateInfo& En
                 NextExt  = &EnabledExtFeats.ShaderDrawParameters.pNext;
             }
 
+            if (EnabledFeaturesVk.DynamicRendering)
+            {
+                VERIFY_EXPR(PhysicalDevice->IsExtensionSupported(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME));
+                DeviceExtensions.push_back(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
+
+                EnabledExtFeats.DynamicRendering = DeviceExtFeatures.DynamicRendering;
+
+                *NextExt = &EnabledExtFeats.DynamicRendering;
+                NextExt  = &EnabledExtFeats.DynamicRendering.pNext;
+            }
+
             // Append user-defined features
             *NextExt = EngineCI.pDeviceExtensionFeatures;
         }
diff --git a/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp b/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
@@ -2059,6 +2059,25 @@ DeviceFeatures VkFeaturesToDeviceFeatures(uint32_t
     return Features;
 }
 
+DeviceFeaturesVk PhysicalDeviceFeaturesToDeviceFeaturesVk(const VulkanUtilities::VulkanPhysicalDevice::ExtensionFeatures& ExtFeatures,
+                                                          DEVICE_FEATURE_STATE                                            OptionalState)
+{
+    VERIFY_EXPR(OptionalState != DEVICE_FEATURE_STATE_DISABLED);
+
+    DeviceFeaturesVk FeaturesVk;
+
+#define INIT_FEATURE(FeatureName, Supported) \
+    FeaturesVk.FeatureName = (Supported) ? OptionalState : DEVICE_FEATURE_STATE_DISABLED
+
+    INIT_FEATURE(DynamicRendering, ExtFeatures.DynamicRendering.dynamicRendering != VK_FALSE);
+
+#undef INIT_FEATURE
+
+    ASSERT_SIZEOF(DeviceFeaturesVk, 1, "Did you add a new feature to DeviceFeaturesVk? Please handle its status here (if necessary).");
+
+    return FeaturesVk;
+}
+
 SPARSE_TEXTURE_FLAGS VkSparseImageFormatFlagsToSparseTextureFlags(VkSparseImageFormatFlags Flags)
 {
     SPARSE_TEXTURE_FLAGS Result = SPARSE_TEXTURE_FLAG_NONE;
diff --git a/ReleaseHistory.md b/ReleaseHistory.md
@@ -1,5 +1,6 @@
 ## Current progress
 
+* Added `DeviceFeaturesVk` struct and `EngineVkCreateInfo::FeaturesVk` member (API256004)
 * Removed `DRAW_FLAG_VERIFY_RENDER_TARGETS` flag (API256003)
   * The validation uses render target formats hash, which allows detecting format mismatches
     without overhead.
