Immediate-mode renderer, triangle demo, shader compilation in cmake, Agility SDKHEADmain

1 files changed, 729 insertions, 0 deletions

diff --git a/contrib/DirectX-Headers-1.618.2/test/feature_check_test.cpp b/contrib/DirectX-Headers-1.618.2/test/feature_check_test.cpp
new file mode 100644
index 0000000..3df3774
--- /dev/null
+++ b/contrib/DirectX-Headers-1.618.2/test/feature_check_test.cpp
@@ -0,0 +1,729 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include <wsl/winadapter.h>
+
+#include <iostream>
+#include <directx/d3d12.h>
+#include <directx/dxcore.h>
+#include <directx/d3dx12.h>
+#include "dxguids/dxguids.h"
+
+#include <wrl/client.h>
+
+// -----------------------------------------------------------------------------------------------------------------
+// Helper Macros for verifying feature check results
+// -----------------------------------------------------------------------------------------------------------------
+
+// Verifies the correctness of a feature check that should not fail
+#define VERIFY_FEATURE_CHECK_NO_DEFAULT(Feature) \
+{ \
+    if (features.Feature() != Data.Feature) \
+    { \
+        std::cout << "Verification failed: " << #Feature << std::endl \
+                  << "Old API: " << Data.Feature << std::endl \
+                  << "New API: " << features.Feature() << std::endl; \
+        return -1; \
+    } \
+}
+
+// Verifies the return value from a feature check with a different name from the old API that should not fail
+#define VERIFY_RENAMED_FEATURE_CHECK_NO_DEFAULT(NewFeature, OldFeature) \
+{ \
+    if (features.NewFeature() != Data.OldFeature) \
+    { \
+        std::cout << "Verification failed: " << #NewFeature << std::endl \
+                  << "Old API: " << Data.OldFeature << std::endl \
+                  << "New API: " << features.NewFeature() << std::endl; \
+        return -1; \
+    } \
+}
+
+// Verifies if the feature check returns the correct default value upon failure
+#define VERIFY_DEFAULT(Feature, Default) \
+{ \
+    if (features.Feature() != Default) \
+    { \
+        std::cout << "Verification failed: " << #Feature << std::endl \
+                  << "Default: " << Default << std::endl \
+                  << "Actual: " << features.Feature() << std::endl; \
+        return -1; \
+    } \
+}
+
+// Verifies the result of a feature check.
+// If the feature check failed because it's not supported by runtime, ensures that it returns the default value
+#define VERIFY_FEATURE_CHECK(Feature, Default) \
+{ \
+    if (FAILED(InitResult)) \
+    { \
+        VERIFY_DEFAULT(Feature, Default); \
+    } \
+    else \
+    { \
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(Feature); \
+    } \
+}
+
+// Verifies the result of a feature check. The requested capability may have a different name in the new API
+// If the feature check failed because it's not supported by runtime, ensures that it returns the default value
+#define VERIFY_RENAMED_FEATURE_CHECK(Feature, OldName, Default) \
+{ \
+    if (FAILED(InitResult)) \
+    { \
+        VERIFY_DEFAULT(Feature, Default); \
+    } \
+    else \
+    { \
+        VERIFY_RENAMED_FEATURE_CHECK_NO_DEFAULT(Feature, OldName); \
+    } \
+}
+
+// Initialize the feature support data structure to be used in the original CheckFeatureSupport API
+#define INITIALIZE_FEATURE_SUPPORT_DATA(FeatureName) \
+HRESULT InitResult; \
+if (FAILED(InitResult = device->CheckFeatureSupport(D3D12_FEATURE_##FeatureName, &Data, sizeof(D3D12_FEATURE_DATA_##FeatureName)))) \
+{ \
+    std::cout << "Feature not supported by device: " << #FeatureName << std::endl; \
+}
+
+// Prints out the mismatched feature check result to stdout
+#define PRINT_CHECK_FAILED_MESSAGE(FeatureName, OldFeature, NewFeature) \
+std::cout << "Verification failed: " << #FeatureName << std::endl \
+          << "Old API: " << OldFeature << std::endl \
+          << "New API: " << NewFeature << std::endl;
+
+
+using namespace Microsoft::WRL;
+
+// To get property value from adapter
+std::vector<char> get_adapter_property(ComPtr<IDXCoreAdapter> adapter, DXCoreAdapterProperty property)
+{
+    if (adapter->IsPropertySupported(property))
+    {
+        size_t len;
+        if(FAILED(adapter->GetPropertySize(property, &len)))
+        {
+            return {};
+        }
+        std::vector<char> buf(len);
+        if(FAILED(adapter->GetProperty(property, len, buf.data())))
+        {
+            return {};
+        }
+        return buf;
+    }
+    return {};
+}
+
+// To get driver description for display before test
+std::string get_driver_description(ComPtr<IDXCoreAdapter> adapter)
+{
+    auto rs = get_adapter_property(adapter, DXCoreAdapterProperty::DriverDescription);
+    std::string name(rs.data());
+    return name;
+}
+
+// -----------------------------------------------------------------------------------------------------------------
+// Run tests on a specific device which is created from the input adapter
+// -----------------------------------------------------------------------------------------------------------------
+int run_per_adapter(IUnknown* adapter)
+{
+    ID3D12Device *device = nullptr;
+
+    if (FAILED(D3D12CreateDevice(adapter, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&device)))) 
+    {
+        return -1;
+    }
+
+    // Initialize the new FeatureSupport class
+    // Notice that it is shared among all feature checks
+    CD3DX12FeatureSupport features;
+    if (FAILED(features.Init(device)))
+    {
+        return -1;
+    }
+
+    UINT NodeCount = device->GetNodeCount();
+
+    // Each feature comes with two code sections
+    // The first section shows how to use the API's of the new FeautreSupport class
+    // The second section contains tests that ensures the new API returns the same result as the old API
+    // 0: D3D12_OPTIONS
+    {
+        BOOL DoublePrecisionFloatShaderOps = features.DoublePrecisionFloatShaderOps();
+        BOOL OutputMergerLogicOp = features.OutputMergerLogicOp();
+        D3D12_TILED_RESOURCES_TIER TiledResourceTier = features.TiledResourcesTier();
+        D3D12_RESOURCE_BINDING_TIER ResourceBindingTier = features.ResourceBindingTier();
+        BOOL PSSpecifiedStencilRefSupported = features.PSSpecifiedStencilRefSupported();
+        BOOL TypedUAVLoadAdditionalFormats = features.TypedUAVLoadAdditionalFormats();
+        BOOL ROVsSupported = features.ROVsSupported();
+        D3D12_CONSERVATIVE_RASTERIZATION_TIER ConservativeRasterizationTier = features.ConservativeRasterizationTier();
+        BOOL StandardSwizzle64KBSupported = features.StandardSwizzle64KBSupported();
+        BOOL CrossAdapterRowMajorTextureSupported = features.CrossAdapterRowMajorTextureSupported();
+        BOOL VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation = features.VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation();
+        D3D12_RESOURCE_HEAP_TIER ResourceHeapTier = features.ResourceHeapTier();
+        D3D12_CROSS_NODE_SHARING_TIER CrossNodeSharingTier = features.CrossNodeSharingTier();
+        UINT MaxGPUVirtualAddressBitsPerResource = features.MaxGPUVirtualAddressBitsPerResource();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS Data = {};
+        device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, &Data, sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS));
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(DoublePrecisionFloatShaderOps);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(OutputMergerLogicOp);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(TiledResourcesTier);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(ResourceBindingTier);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(PSSpecifiedStencilRefSupported);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(TypedUAVLoadAdditionalFormats);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(ROVsSupported);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(ConservativeRasterizationTier);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(StandardSwizzle64KBSupported);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(CrossAdapterRowMajorTextureSupported);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(ResourceHeapTier);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(CrossNodeSharingTier);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(MaxGPUVirtualAddressBitsPerResource);
+    }
+
+    // 2: Feature Levels
+    {
+        D3D_FEATURE_LEVEL HighestLevelSupported = features.MaxSupportedFeatureLevel();
+        
+        D3D12_FEATURE_DATA_FEATURE_LEVELS Data = {};
+        D3D_FEATURE_LEVEL KnownFeatureLevels[] =
+        {
+            D3D_FEATURE_LEVEL_1_0_CORE,
+            D3D_FEATURE_LEVEL_9_1,
+            D3D_FEATURE_LEVEL_9_2,
+            D3D_FEATURE_LEVEL_9_3,
+            D3D_FEATURE_LEVEL_10_0,
+            D3D_FEATURE_LEVEL_10_1,
+            D3D_FEATURE_LEVEL_11_0,
+            D3D_FEATURE_LEVEL_11_1,
+            D3D_FEATURE_LEVEL_12_0,
+            D3D_FEATURE_LEVEL_12_1,
+            D3D_FEATURE_LEVEL_12_2
+        };
+        Data.pFeatureLevelsRequested = KnownFeatureLevels;
+        Data.NumFeatureLevels = sizeof(KnownFeatureLevels) / sizeof(D3D_FEATURE_LEVEL);
+        device->CheckFeatureSupport(D3D12_FEATURE_FEATURE_LEVELS, &Data, sizeof(D3D12_FEATURE_DATA_FEATURE_LEVELS));
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(MaxSupportedFeatureLevel);
+    }
+
+    // 3: Format Support
+    {
+        D3D12_FORMAT_SUPPORT1 Support1;
+        D3D12_FORMAT_SUPPORT2 Support2;
+        if (FAILED(features.FormatSupport(DXGI_FORMAT_R16G16B16A16_FLOAT, Support1, Support2))) {
+            std::cout << "Error: FormatSupport failed" << std::endl;
+            return -1;
+        }
+
+        D3D12_FEATURE_DATA_FORMAT_SUPPORT Data = {};
+        Data.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
+        if (SUCCEEDED(device->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT, &Data, sizeof(D3D12_FEATURE_DATA_FORMAT_SUPPORT)))) 
+        {
+            if (Support1 != Data.Support1)
+            {
+                std::cout << "Verification failed: " << "FormatSupport1" << std::endl 
+                          << "Old API: " << Data.Support1 << std::endl 
+                          << "New API: " << Support1 << std::endl; 
+                return -1;
+            }
+
+            if (Support2 != Data.Support2)
+            {
+                std::cout << "Verification failed: " << "FormatSupport2" << std::endl 
+                          << "Old API: " << Data.Support2 << std::endl 
+                          << "New API: " << Support2 << std::endl; 
+                return -1;
+            }
+        }
+    }
+
+    // 4: Multisample Quality Support
+    {
+        UINT NumQualityLevels;
+        if (FAILED(features.MultisampleQualityLevels(DXGI_FORMAT_R16G16B16A16_FLOAT, 1, D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE, NumQualityLevels))) {
+            std::cout << "Error: MultisampleQualityLevels failed" << std::endl;
+            return -1;
+        }
+
+        D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS Data = {};
+        Data.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
+        Data.Flags = D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE;
+        Data.SampleCount = 1;
+        device->CheckFeatureSupport(D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS, &Data, sizeof(D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS));
+        if (NumQualityLevels != Data.NumQualityLevels)
+        {
+            std::cout << "Verification failed: " << "MultisampleQualityLevels" << std::endl 
+                        << "Old API: " << Data.NumQualityLevels << std::endl 
+                        << "New API: " << NumQualityLevels << std::endl; 
+            return -1;
+        }
+    }
+
+    // 5: Format Info
+    {
+        UINT8 PlaneCount;
+        if (FAILED(features.FormatInfo(DXGI_FORMAT_R16G16B16A16_FLOAT, PlaneCount))) 
+        {
+            std::cout << "Error: FormatInfo failed" << std::endl;
+            return -1;
+        }
+
+        D3D12_FEATURE_DATA_FORMAT_INFO Data = {};
+        Data.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
+        device->CheckFeatureSupport(D3D12_FEATURE_FORMAT_INFO, &Data, sizeof(D3D12_FEATURE_DATA_FORMAT_INFO));
+        if (PlaneCount != Data.PlaneCount)
+        {
+            PRINT_CHECK_FAILED_MESSAGE(FormatInfo, Data.PlaneCount, PlaneCount);
+        }
+    }
+
+    // 6: GPU Virtual Address Support
+    {
+        UINT MaxGPUVABitsPerProcess = features.MaxGPUVirtualAddressBitsPerProcess();
+        UINT MaxGPUVABitsPerResource = features.MaxGPUVirtualAddressBitsPerResource();
+
+        D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT Data = {};
+        device->CheckFeatureSupport(D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT, &Data, sizeof(D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT));
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(MaxGPUVirtualAddressBitsPerProcess);
+        VERIFY_FEATURE_CHECK_NO_DEFAULT(MaxGPUVirtualAddressBitsPerResource);
+    }
+
+    // 7: Shader Model
+    {
+        D3D_SHADER_MODEL HighestShaderModel = features.HighestShaderModel();
+
+        D3D12_FEATURE_DATA_SHADER_MODEL Data = {};
+        D3D_SHADER_MODEL KnownShaderModels[] =
+        {
+            D3D_SHADER_MODEL_6_7,
+            D3D_SHADER_MODEL_6_6,
+            D3D_SHADER_MODEL_6_5,
+            D3D_SHADER_MODEL_6_4,
+            D3D_SHADER_MODEL_6_3,
+            D3D_SHADER_MODEL_6_2,
+            D3D_SHADER_MODEL_6_1,
+            D3D_SHADER_MODEL_6_0,
+            D3D_SHADER_MODEL_5_1
+        };
+        UINT NumKnownShaderModels = sizeof(KnownShaderModels) / sizeof(D3D_SHADER_MODEL);
+        for (UINT i = 0; i < NumKnownShaderModels; i++)
+        {
+            Data.HighestShaderModel = D3D_SHADER_MODEL_6_7; // Highest Known Shader Model
+            if (SUCCEEDED(device->CheckFeatureSupport(D3D12_FEATURE_SHADER_MODEL, &Data, sizeof(D3D12_FEATURE_DATA_SHADER_MODEL)))) 
+            {
+                VERIFY_FEATURE_CHECK_NO_DEFAULT(HighestShaderModel);
+            }
+        }
+    }
+    
+    // 8: Options1
+    {
+        BOOL WaveOps = features.WaveOps();
+        UINT WaveLaneCountMin = features.WaveLaneCountMin();
+        UINT WaveLaneCountMax = features.WaveLaneCountMax();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS1 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS1);
+        VERIFY_FEATURE_CHECK(WaveOps, false);
+        VERIFY_FEATURE_CHECK(WaveLaneCountMax, 0);
+        VERIFY_FEATURE_CHECK(WaveLaneCountMin, 0);
+    }
+
+    // 10: Protected Resource Session Support
+    for (UINT NodeId = 0; NodeId < NodeCount; NodeId++)
+    {
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS ProtectedResourceSessionSupport = features.ProtectedResourceSessionSupport(NodeId);
+
+        D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT Data = {};
+        Data.NodeIndex = NodeId;
+        INITIALIZE_FEATURE_SUPPORT_DATA(PROTECTED_RESOURCE_SESSION_SUPPORT);
+        VERIFY_RENAMED_FEATURE_CHECK(ProtectedResourceSessionSupport, Support, D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE);
+    }
+
+    // 12: Root Signature
+    {
+        D3D_ROOT_SIGNATURE_VERSION HighestRootSignatureVersion = features.HighestRootSignatureVersion();
+
+        D3D12_FEATURE_DATA_ROOT_SIGNATURE Data = {};
+        Data.HighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_1; // Highest Known Version
+        INITIALIZE_FEATURE_SUPPORT_DATA(ROOT_SIGNATURE);
+        VERIFY_RENAMED_FEATURE_CHECK(HighestRootSignatureVersion, HighestVersion, (D3D_ROOT_SIGNATURE_VERSION)0);
+    }
+
+    // 16: Architecture1
+    for (UINT NodeId = 0; NodeId < NodeCount; NodeId++)
+    {
+        BOOL IsolatedMMU = features.IsolatedMMU(NodeId);
+        BOOL TileBasedRenderer = features.TileBasedRenderer(NodeId);
+        BOOL UMA = features.UMA(NodeId);
+        BOOL CacheCoherentUMA = features.CacheCoherentUMA(NodeId);
+
+        D3D12_FEATURE_DATA_ARCHITECTURE1 Data = {};
+        Data.NodeIndex = NodeId;
+        INITIALIZE_FEATURE_SUPPORT_DATA(ARCHITECTURE1);
+        if (FAILED(InitResult)) 
+        {
+            D3D12_FEATURE_DATA_ARCHITECTURE Data = {};
+            Data.NodeIndex = NodeId;
+            INITIALIZE_FEATURE_SUPPORT_DATA(ARCHITECTURE);
+            VERIFY_FEATURE_CHECK_NO_DEFAULT(TileBasedRenderer);
+            VERIFY_FEATURE_CHECK_NO_DEFAULT(UMA);
+            VERIFY_FEATURE_CHECK_NO_DEFAULT(CacheCoherentUMA);
+        }
+        else
+        {
+            VERIFY_FEATURE_CHECK(TileBasedRenderer, false);
+            VERIFY_FEATURE_CHECK(UMA, false);
+            VERIFY_FEATURE_CHECK(CacheCoherentUMA, false);
+        }
+        VERIFY_FEATURE_CHECK(IsolatedMMU, false);
+    }
+
+    // 18: Options2
+    {
+        BOOL DepthBoundsTestSupported = features.DepthBoundsTestSupported();
+        D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER ProgrammableSamplePositionsTier = features.ProgrammableSamplePositionsTier();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS2 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS2);
+        VERIFY_FEATURE_CHECK(DepthBoundsTestSupported, false);
+        VERIFY_FEATURE_CHECK(ProgrammableSamplePositionsTier, D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED);
+    }
+
+    // 19: Shader Cache
+    {
+        D3D12_SHADER_CACHE_SUPPORT_FLAGS ShaderCacheSupportFlags = features.ShaderCacheSupportFlags();
+
+        D3D12_FEATURE_DATA_SHADER_CACHE Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(SHADER_CACHE);
+        VERIFY_RENAMED_FEATURE_CHECK(ShaderCacheSupportFlags, SupportFlags, D3D12_SHADER_CACHE_SUPPORT_NONE);
+    }
+
+    // 20: Command Queue Prioirity
+    {
+        // Basic check
+        BOOL CommandQueuePrioritySupportedPositive = features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_PRIORITY_NORMAL);
+        // Check for Global Realtime support
+        BOOL CommandQueuePrioritySupportedRealtime = features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_COPY, D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME);
+        // Test on invalid inputs
+        BOOL CommandQueuePrioritySupportedInvalid = features.CommandQueuePrioritySupported((D3D12_COMMAND_LIST_TYPE)7, 0);
+
+        D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY Data = {};
+        {
+            Data.CommandListType = D3D12_COMMAND_LIST_TYPE_DIRECT;
+            Data.Priority = D3D12_COMMAND_QUEUE_PRIORITY_NORMAL;
+            INITIALIZE_FEATURE_SUPPORT_DATA(COMMAND_QUEUE_PRIORITY);
+            if (CommandQueuePrioritySupportedPositive != Data.PriorityForTypeIsSupported)
+            {
+                PRINT_CHECK_FAILED_MESSAGE(CommandQueuePriority, Data.PriorityForTypeIsSupported, CommandQueuePrioritySupportedPositive);
+            }
+        }
+
+        {
+            Data.CommandListType = D3D12_COMMAND_LIST_TYPE_COPY;
+            Data.Priority = D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME;
+            INITIALIZE_FEATURE_SUPPORT_DATA(COMMAND_QUEUE_PRIORITY);
+            if (CommandQueuePrioritySupportedRealtime != Data.PriorityForTypeIsSupported)
+            {
+                PRINT_CHECK_FAILED_MESSAGE(CommandQueuePriority, Data.PriorityForTypeIsSupported, CommandQueuePrioritySupportedRealtime);
+            }
+        }
+
+        if (CommandQueuePrioritySupportedInvalid)
+        {
+            std::cout << "Error: Wrong result from Command Queue Priority - Invalid Test Case\n"
+                      << "New API returned true on invalid Command List Types\n"
+                      << "Check if the list of command list types has updated\n";
+            return -1;
+        }
+    }
+
+    // 21: Options3
+    {
+        BOOL CopyQueueTimestampQueriesSupported = features.CopyQueueTimestampQueriesSupported();
+        BOOL CastingFullyTypedFormatSupported = features.CastingFullyTypedFormatSupported();
+        D3D12_COMMAND_LIST_SUPPORT_FLAGS WriteBufferImmediateSupportFlags = features.WriteBufferImmediateSupportFlags();
+        D3D12_VIEW_INSTANCING_TIER ViewInstancingTier = features.ViewInstancingTier();
+        BOOL BarycentricsSupported = features.BarycentricsSupported();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS3 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS3);
+        VERIFY_FEATURE_CHECK(CopyQueueTimestampQueriesSupported, false);
+        VERIFY_FEATURE_CHECK(CastingFullyTypedFormatSupported, false);
+        VERIFY_FEATURE_CHECK(WriteBufferImmediateSupportFlags, D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE);
+        VERIFY_FEATURE_CHECK(ViewInstancingTier, D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED);
+        VERIFY_FEATURE_CHECK(BarycentricsSupported, false);
+    }
+
+    // 22: Existing Heaps
+    {
+        BOOL ExistingHeapsSupported = features.ExistingHeapsSupported();
+        
+        D3D12_FEATURE_DATA_EXISTING_HEAPS Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(EXISTING_HEAPS);
+        VERIFY_RENAMED_FEATURE_CHECK(ExistingHeapsSupported, Supported, false);
+    }
+
+    // 23: D3D12 Options4
+    {
+        BOOL MSAA64KBAlignedTextureSupported = features.MSAA64KBAlignedTextureSupported();
+        D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier = features.SharedResourceCompatibilityTier();
+        BOOL Native16BitShaderOpsSupported = features.Native16BitShaderOpsSupported();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS4 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS4);
+        VERIFY_FEATURE_CHECK(MSAA64KBAlignedTextureSupported, false);
+        VERIFY_FEATURE_CHECK(SharedResourceCompatibilityTier, D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0);
+        VERIFY_FEATURE_CHECK(Native16BitShaderOpsSupported, false);
+    }
+
+    // 24: Serialization
+    {
+        D3D12_HEAP_SERIALIZATION_TIER HeapSerializationTier = features.HeapSerializationTier();
+        D3D12_FEATURE_DATA_SERIALIZATION Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(SERIALIZATION);
+        VERIFY_FEATURE_CHECK(HeapSerializationTier, D3D12_HEAP_SERIALIZATION_TIER_0);
+    }
+
+    // 25: Cross Node
+    {
+        BOOL CrossNodeAtomicShaderInstructions = features.CrossNodeAtomicShaderInstructions();
+        D3D12_FEATURE_DATA_CROSS_NODE Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(CROSS_NODE);
+        VERIFY_RENAMED_FEATURE_CHECK(CrossNodeAtomicShaderInstructions, AtomicShaderInstructions, false);
+    }
+
+    // 27: Options5
+    {
+        BOOL SRVOnlyTiledResourceTier3 = features.SRVOnlyTiledResourceTier3();
+        D3D12_RENDER_PASS_TIER RenderPassesTier = features.RenderPassesTier();
+        D3D12_RAYTRACING_TIER RaytracingTier = features.RaytracingTier();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS5 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS5);
+        VERIFY_FEATURE_CHECK(SRVOnlyTiledResourceTier3, false);
+        VERIFY_FEATURE_CHECK(RenderPassesTier, D3D12_RENDER_PASS_TIER_0);
+        VERIFY_FEATURE_CHECK(RaytracingTier, D3D12_RAYTRACING_TIER_NOT_SUPPORTED);
+    }
+
+    // 28: Displayable
+    {
+        BOOL DisplayableTexture = features.DisplayableTexture();
+
+        D3D12_FEATURE_DATA_DISPLAYABLE Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(DISPLAYABLE);
+        VERIFY_FEATURE_CHECK(DisplayableTexture, false);
+    }
+
+    // 30: Options6
+    {
+        BOOL AdditionalShadingRatesSupported = features.AdditionalShadingRatesSupported();
+        BOOL PerPrimitiveShadingRateSupportedWithViewportIndexing = features.PerPrimitiveShadingRateSupportedWithViewportIndexing();
+        D3D12_VARIABLE_SHADING_RATE_TIER VariableShadingRateTier = features.VariableShadingRateTier();
+        BOOL ShadingRateImageTileSize = features.ShadingRateImageTileSize();
+        BOOL BackgroundProcessingSupported = features.BackgroundProcessingSupported();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS6 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS6);
+        VERIFY_FEATURE_CHECK(AdditionalShadingRatesSupported, false);
+        VERIFY_FEATURE_CHECK(PerPrimitiveShadingRateSupportedWithViewportIndexing, false);
+        VERIFY_FEATURE_CHECK(VariableShadingRateTier, D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED);
+        VERIFY_FEATURE_CHECK(ShadingRateImageTileSize, false);
+        VERIFY_FEATURE_CHECK(BackgroundProcessingSupported, false);
+    }
+
+    // 31: Query Metacommand
+    // The function is simply a forwarding call to the old API
+    // Takes in a pointer to D3D12_FEATURE_DATA_QUERY_METACOMMAND as input parameter
+    // No need to test specifically
+
+    // 32: Options7
+    {
+        D3D12_MESH_SHADER_TIER MeshShaderTier = features.MeshShaderTier();
+        D3D12_SAMPLER_FEEDBACK_TIER SamplerFeedbackTier = features.SamplerFeedbackTier();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS7 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS7);
+        VERIFY_FEATURE_CHECK(MeshShaderTier, D3D12_MESH_SHADER_TIER_NOT_SUPPORTED);
+        VERIFY_FEATURE_CHECK(SamplerFeedbackTier, D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED);
+    }
+
+    // 33: Session Type Count
+    for (UINT NodeId = 0; NodeId < NodeCount; NodeId++)
+    {
+        UINT ProtectedResourceSessionTypeCount = features.ProtectedResourceSessionTypeCount(NodeId);
+
+        D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT Data = {};
+        Data.NodeIndex = NodeId;
+        INITIALIZE_FEATURE_SUPPORT_DATA(PROTECTED_RESOURCE_SESSION_TYPE_COUNT);
+        VERIFY_RENAMED_FEATURE_CHECK(ProtectedResourceSessionTypeCount, Count, 0);
+    }
+    
+    // 34: Session Types
+    for (UINT NodeId = 0; NodeId < NodeCount; NodeId++)
+    {
+        std::vector<GUID> ProtectedResourceSessionTypes = features.ProtectedResourceSessionTypes(NodeId);
+
+        D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT CountData = {};
+        CountData.NodeIndex = NodeId;
+        if (FAILED(device->CheckFeatureSupport(D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPE_COUNT, &CountData, sizeof(D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT))))
+        {
+            if (ProtectedResourceSessionTypes.size() != 0)
+            {
+                std::cout << "Error: Wrong result from Protected Resource Session Types on Node " << NodeId << std::endl
+                          << "Type count check failed but types vector is not empty\n";
+                return -1;
+            }
+            continue;
+        }
+        
+        if (CountData.Count != ProtectedResourceSessionTypes.size())
+        {
+            std::cout << "Error: Wrong result from Protected Resource Session Types on Node " << NodeId << std::endl
+                      << "Types vector size does not equal type count\n";
+            return -1;
+        }
+
+        D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES Data = {};
+        Data.NodeIndex = NodeId;
+        Data.Count = CountData.Count;
+        Data.pTypes = new GUID[Data.Count];
+        INITIALIZE_FEATURE_SUPPORT_DATA(PROTECTED_RESOURCE_SESSION_TYPES);
+        if (SUCCEEDED(InitResult))
+        {
+            for (unsigned int i = 0; i < Data.Count; i++)
+            {
+                if (ProtectedResourceSessionTypes[i] != Data.pTypes[i])
+                {
+                    std::cout << "Error: Result mismatch from Proteted Resource Session Types\n"
+                              << "Node Index: " << NodeId << std::endl
+                              << "Type Index: " << i << std::endl;
+                    return -1;
+                }
+            }
+        }
+    }
+
+    // 36: Options8
+    {
+        BOOL UnalignedBlockTexturesSupported = features.UnalignedBlockTexturesSupported();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS8 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS8);
+        VERIFY_FEATURE_CHECK(UnalignedBlockTexturesSupported, false);
+    }
+
+    // 37: Options9
+    {
+        BOOL MeshShaderPipelineStatsSupported = features.MeshShaderPipelineStatsSupported();
+        BOOL MeshShaderSupportsFullRangeRenderTargetArrayIndex = features.MeshShaderSupportsFullRangeRenderTargetArrayIndex();
+        D3D12_WAVE_MMA_TIER WaveMMATier = features.WaveMMATier();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS9 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS9);
+        VERIFY_FEATURE_CHECK(MeshShaderPipelineStatsSupported, false);
+        VERIFY_FEATURE_CHECK(MeshShaderSupportsFullRangeRenderTargetArrayIndex, false);
+        VERIFY_FEATURE_CHECK(WaveMMATier, D3D12_WAVE_MMA_TIER_NOT_SUPPORTED);
+    }
+
+    // 39: Options10
+    {
+        BOOL VariableRateShadingSumCombinerSupported = features.VariableRateShadingSumCombinerSupported();
+        BOOL MeshShaderPerPrimitiveShadingRateSupported = features.MeshShaderPerPrimitiveShadingRateSupported();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS10 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS10);
+        VERIFY_FEATURE_CHECK(VariableRateShadingSumCombinerSupported, false);
+        VERIFY_FEATURE_CHECK(MeshShaderPerPrimitiveShadingRateSupported, false);
+    }
+
+    // 40: Options11
+    {
+        BOOL AtomicInt64OnDescriptorHeapResourceSupported = features.AtomicInt64OnDescriptorHeapResourceSupported();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS11 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS11);
+        VERIFY_FEATURE_CHECK(AtomicInt64OnDescriptorHeapResourceSupported, false);
+    }
+
+    // 41: Options12
+    {
+        D3D12_TRI_STATE MSPrimitivesPipelineStatisticIncludesCulledPrimitives = features.MSPrimitivesPipelineStatisticIncludesCulledPrimitives();
+        BOOL EnhancedBarriersSupported = features.EnhancedBarriersSupported();
+
+        D3D12_FEATURE_DATA_D3D12_OPTIONS12 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS12);
+        VERIFY_FEATURE_CHECK(MSPrimitivesPipelineStatisticIncludesCulledPrimitives, D3D12_TRI_STATE_UNKNOWN);
+        VERIFY_FEATURE_CHECK(EnhancedBarriersSupported, false);
+        VERIFY_FEATURE_CHECK(RelaxedFormatCastingSupported, false);
+    }
+
+    // 41: Options13
+    {
+        D3D12_FEATURE_DATA_D3D12_OPTIONS13 Data = {};
+        INITIALIZE_FEATURE_SUPPORT_DATA(D3D12_OPTIONS13);
+        VERIFY_FEATURE_CHECK(UnrestrictedBufferTextureCopyPitchSupported, false);
+        VERIFY_FEATURE_CHECK(UnrestrictedVertexElementAlignmentSupported, false);
+        VERIFY_FEATURE_CHECK(InvertedViewportHeightFlipsYSupported, false);
+        VERIFY_FEATURE_CHECK(InvertedViewportDepthFlipsZSupported, false);
+        VERIFY_FEATURE_CHECK(TextureCopyBetweenDimensionsSupported, false);
+        VERIFY_FEATURE_CHECK(AlphaBlendFactorSupported, false);
+    }
+
+    std::cout << "Test completed with no errors." << std::endl;
+    return 0;
+}
+
+#ifdef __MINGW32__
+STDAPI
+DXCoreCreateAdapterFactory(
+    REFIID riid,
+    _COM_Outptr_ void** ppvFactory
+) {
+    return 0;
+}
+#endif
+
+int main()
+{
+    ComPtr<IDXCoreAdapterFactory> adapter_factory;
+    ComPtr<IDXCoreAdapterList> adapter_list;
+    GUID dx_must_attr[1]{ DXCORE_ADAPTER_ATTRIBUTE_D3D12_CORE_COMPUTE };
+
+    if(FAILED(DXCoreCreateAdapterFactory(IID_PPV_ARGS(&adapter_factory))))
+    {
+        return -1;
+    }
+
+    if(FAILED(adapter_factory->CreateAdapterList(_countof(dx_must_attr), dx_must_attr, IID_PPV_ARGS(&adapter_list))))
+    {
+        return -1;
+    }
+
+    // Test all adapters
+    for (uint32_t i = 0; i < adapter_list->GetAdapterCount(); i++)
+    {
+        ComPtr<IDXCoreAdapter> adapter;
+        if(FAILED(adapter_list->GetAdapter(i, IID_PPV_ARGS(&adapter))))
+        {
+            std::cout << "Cannot get number " << i << " adapter." << std::endl;
+            continue;
+        }
+
+        std::string driver_desc_str = get_driver_description(adapter);
+        if(driver_desc_str.empty())
+        {
+            std::cout << "Cannot get number " << i << " adapter's driver description." << std::endl;
+        }
+        std::cout << "Test on device driver: " << driver_desc_str << std::endl;
+
+        if(FAILED(run_per_adapter(adapter.Get())))
+        {
+            std::cout << "Some tests failed with error on number " << i << " adapter." << std::endl;
+        }
+    }
+    return 0;
+}
\ No newline at end of file